github.com/vtorhonen/terraform@v0.9.0-beta2.0.20170307220345-5d894e4ffda7/command/import_test.go (about) 1 package command 2 3 import ( 4 "fmt" 5 "testing" 6 7 "github.com/hashicorp/terraform/terraform" 8 "github.com/mitchellh/cli" 9 ) 10 11 func TestImport(t *testing.T) { 12 statePath := testTempFile(t) 13 14 p := testProvider() 15 ui := new(cli.MockUi) 16 c := &ImportCommand{ 17 Meta: Meta{ 18 ContextOpts: testCtxConfig(p), 19 Ui: ui, 20 }, 21 } 22 23 p.ImportStateFn = nil 24 p.ImportStateReturn = []*terraform.InstanceState{ 25 &terraform.InstanceState{ 26 ID: "yay", 27 Ephemeral: terraform.EphemeralState{ 28 Type: "test_instance", 29 }, 30 }, 31 } 32 33 args := []string{ 34 "-state", statePath, 35 "test_instance.foo", 36 "bar", 37 } 38 if code := c.Run(args); code != 0 { 39 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 40 } 41 42 if !p.ImportStateCalled { 43 t.Fatal("ImportState should be called") 44 } 45 46 testStateOutput(t, statePath, testImportStr) 47 } 48 49 func TestImport_providerConfig(t *testing.T) { 50 defer testChdir(t, testFixturePath("import-provider"))() 51 52 statePath := testTempFile(t) 53 54 p := testProvider() 55 ui := new(cli.MockUi) 56 c := &ImportCommand{ 57 Meta: Meta{ 58 ContextOpts: testCtxConfig(p), 59 Ui: ui, 60 }, 61 } 62 63 p.ImportStateFn = nil 64 p.ImportStateReturn = []*terraform.InstanceState{ 65 &terraform.InstanceState{ 66 ID: "yay", 67 Ephemeral: terraform.EphemeralState{ 68 Type: "test_instance", 69 }, 70 }, 71 } 72 73 configured := false 74 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 75 configured = true 76 77 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 78 return fmt.Errorf("bad value: %#v", v) 79 } 80 81 return nil 82 } 83 84 args := []string{ 85 "-state", statePath, 86 "test_instance.foo", 87 "bar", 88 } 89 if code := c.Run(args); code != 0 { 90 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 91 } 92 93 // Verify that we were called 94 if !configured { 95 t.Fatal("Configure should be called") 96 } 97 98 if !p.ImportStateCalled { 99 t.Fatal("ImportState should be called") 100 } 101 102 testStateOutput(t, statePath, testImportStr) 103 } 104 105 func TestImport_providerConfigDisable(t *testing.T) { 106 defer testChdir(t, testFixturePath("import-provider"))() 107 108 statePath := testTempFile(t) 109 110 p := testProvider() 111 ui := new(cli.MockUi) 112 c := &ImportCommand{ 113 Meta: Meta{ 114 ContextOpts: testCtxConfig(p), 115 Ui: ui, 116 }, 117 } 118 119 p.ImportStateFn = nil 120 p.ImportStateReturn = []*terraform.InstanceState{ 121 &terraform.InstanceState{ 122 ID: "yay", 123 Ephemeral: terraform.EphemeralState{ 124 Type: "test_instance", 125 }, 126 }, 127 } 128 129 configured := false 130 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 131 configured = true 132 133 if v, ok := c.Get("foo"); ok { 134 return fmt.Errorf("bad value: %#v", v) 135 } 136 137 return nil 138 } 139 140 args := []string{ 141 "-state", statePath, 142 "-config", "", 143 "test_instance.foo", 144 "bar", 145 } 146 if code := c.Run(args); code != 0 { 147 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 148 } 149 150 // Verify that we were called 151 if !configured { 152 t.Fatal("Configure should be called") 153 } 154 155 if !p.ImportStateCalled { 156 t.Fatal("ImportState should be called") 157 } 158 159 testStateOutput(t, statePath, testImportStr) 160 } 161 162 func TestImport_providerConfigWithVar(t *testing.T) { 163 defer testChdir(t, testFixturePath("import-provider-var"))() 164 165 statePath := testTempFile(t) 166 167 p := testProvider() 168 ui := new(cli.MockUi) 169 c := &ImportCommand{ 170 Meta: Meta{ 171 ContextOpts: testCtxConfig(p), 172 Ui: ui, 173 }, 174 } 175 176 p.ImportStateFn = nil 177 p.ImportStateReturn = []*terraform.InstanceState{ 178 &terraform.InstanceState{ 179 ID: "yay", 180 Ephemeral: terraform.EphemeralState{ 181 Type: "test_instance", 182 }, 183 }, 184 } 185 186 configured := false 187 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 188 configured = true 189 190 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 191 return fmt.Errorf("bad value: %#v", v) 192 } 193 194 return nil 195 } 196 197 args := []string{ 198 "-state", statePath, 199 "-var", "foo=bar", 200 "test_instance.foo", 201 "bar", 202 } 203 if code := c.Run(args); code != 0 { 204 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 205 } 206 207 // Verify that we were called 208 if !configured { 209 t.Fatal("Configure should be called") 210 } 211 212 if !p.ImportStateCalled { 213 t.Fatal("ImportState should be called") 214 } 215 216 testStateOutput(t, statePath, testImportStr) 217 } 218 219 func TestImport_providerConfigWithVarDefault(t *testing.T) { 220 defer testChdir(t, testFixturePath("import-provider-var-default"))() 221 222 statePath := testTempFile(t) 223 224 p := testProvider() 225 ui := new(cli.MockUi) 226 c := &ImportCommand{ 227 Meta: Meta{ 228 ContextOpts: testCtxConfig(p), 229 Ui: ui, 230 }, 231 } 232 233 p.ImportStateFn = nil 234 p.ImportStateReturn = []*terraform.InstanceState{ 235 &terraform.InstanceState{ 236 ID: "yay", 237 Ephemeral: terraform.EphemeralState{ 238 Type: "test_instance", 239 }, 240 }, 241 } 242 243 configured := false 244 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 245 configured = true 246 247 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 248 return fmt.Errorf("bad value: %#v", v) 249 } 250 251 return nil 252 } 253 254 args := []string{ 255 "-state", statePath, 256 "test_instance.foo", 257 "bar", 258 } 259 if code := c.Run(args); code != 0 { 260 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 261 } 262 263 // Verify that we were called 264 if !configured { 265 t.Fatal("Configure should be called") 266 } 267 268 if !p.ImportStateCalled { 269 t.Fatal("ImportState should be called") 270 } 271 272 testStateOutput(t, statePath, testImportStr) 273 } 274 275 func TestImport_providerConfigWithVarFile(t *testing.T) { 276 defer testChdir(t, testFixturePath("import-provider-var-file"))() 277 278 statePath := testTempFile(t) 279 280 p := testProvider() 281 ui := new(cli.MockUi) 282 c := &ImportCommand{ 283 Meta: Meta{ 284 ContextOpts: testCtxConfig(p), 285 Ui: ui, 286 }, 287 } 288 289 p.ImportStateFn = nil 290 p.ImportStateReturn = []*terraform.InstanceState{ 291 &terraform.InstanceState{ 292 ID: "yay", 293 Ephemeral: terraform.EphemeralState{ 294 Type: "test_instance", 295 }, 296 }, 297 } 298 299 configured := false 300 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 301 configured = true 302 303 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 304 return fmt.Errorf("bad value: %#v", v) 305 } 306 307 return nil 308 } 309 310 args := []string{ 311 "-state", statePath, 312 "-var-file", "blah.tfvars", 313 "test_instance.foo", 314 "bar", 315 } 316 if code := c.Run(args); code != 0 { 317 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 318 } 319 320 // Verify that we were called 321 if !configured { 322 t.Fatal("Configure should be called") 323 } 324 325 if !p.ImportStateCalled { 326 t.Fatal("ImportState should be called") 327 } 328 329 testStateOutput(t, statePath, testImportStr) 330 } 331 332 /* 333 func TestRefresh_badState(t *testing.T) { 334 p := testProvider() 335 ui := new(cli.MockUi) 336 c := &RefreshCommand{ 337 Meta: Meta{ 338 ContextOpts: testCtxConfig(p), 339 Ui: ui, 340 }, 341 } 342 343 args := []string{ 344 "-state", "i-should-not-exist-ever", 345 testFixturePath("refresh"), 346 } 347 if code := c.Run(args); code != 1 { 348 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 349 } 350 } 351 352 func TestRefresh_cwd(t *testing.T) { 353 cwd, err := os.Getwd() 354 if err != nil { 355 t.Fatalf("err: %s", err) 356 } 357 if err := os.Chdir(testFixturePath("refresh")); err != nil { 358 t.Fatalf("err: %s", err) 359 } 360 defer os.Chdir(cwd) 361 362 state := testState() 363 statePath := testStateFile(t, state) 364 365 p := testProvider() 366 ui := new(cli.MockUi) 367 c := &RefreshCommand{ 368 Meta: Meta{ 369 ContextOpts: testCtxConfig(p), 370 Ui: ui, 371 }, 372 } 373 374 p.RefreshFn = nil 375 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 376 377 args := []string{ 378 "-state", statePath, 379 } 380 if code := c.Run(args); code != 0 { 381 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 382 } 383 384 if !p.RefreshCalled { 385 t.Fatal("refresh should be called") 386 } 387 388 f, err := os.Open(statePath) 389 if err != nil { 390 t.Fatalf("err: %s", err) 391 } 392 393 newState, err := terraform.ReadState(f) 394 f.Close() 395 if err != nil { 396 t.Fatalf("err: %s", err) 397 } 398 399 actual := strings.TrimSpace(newState.String()) 400 expected := strings.TrimSpace(testRefreshCwdStr) 401 if actual != expected { 402 t.Fatalf("bad:\n\n%s", actual) 403 } 404 } 405 406 func TestRefresh_defaultState(t *testing.T) { 407 originalState := testState() 408 409 // Write the state file in a temporary directory with the 410 // default filename. 411 td, err := ioutil.TempDir("", "tf") 412 if err != nil { 413 t.Fatalf("err: %s", err) 414 } 415 statePath := filepath.Join(td, DefaultStateFilename) 416 417 f, err := os.Create(statePath) 418 if err != nil { 419 t.Fatalf("err: %s", err) 420 } 421 err = terraform.WriteState(originalState, f) 422 f.Close() 423 if err != nil { 424 t.Fatalf("err: %s", err) 425 } 426 427 // Change to that directory 428 cwd, err := os.Getwd() 429 if err != nil { 430 t.Fatalf("err: %s", err) 431 } 432 if err := os.Chdir(filepath.Dir(statePath)); err != nil { 433 t.Fatalf("err: %s", err) 434 } 435 defer os.Chdir(cwd) 436 437 p := testProvider() 438 ui := new(cli.MockUi) 439 c := &RefreshCommand{ 440 Meta: Meta{ 441 ContextOpts: testCtxConfig(p), 442 Ui: ui, 443 }, 444 } 445 446 p.RefreshFn = nil 447 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 448 449 args := []string{ 450 testFixturePath("refresh"), 451 } 452 if code := c.Run(args); code != 0 { 453 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 454 } 455 456 if !p.RefreshCalled { 457 t.Fatal("refresh should be called") 458 } 459 460 f, err = os.Open(statePath) 461 if err != nil { 462 t.Fatalf("err: %s", err) 463 } 464 465 newState, err := terraform.ReadState(f) 466 f.Close() 467 if err != nil { 468 t.Fatalf("err: %s", err) 469 } 470 471 actual := newState.RootModule().Resources["test_instance.foo"].Primary 472 expected := p.RefreshReturn 473 if !reflect.DeepEqual(actual, expected) { 474 t.Fatalf("bad: %#v", actual) 475 } 476 477 f, err = os.Open(statePath + DefaultBackupExtension) 478 if err != nil { 479 t.Fatalf("err: %s", err) 480 } 481 482 backupState, err := terraform.ReadState(f) 483 f.Close() 484 if err != nil { 485 t.Fatalf("err: %s", err) 486 } 487 488 actual = backupState.RootModule().Resources["test_instance.foo"].Primary 489 expected = originalState.RootModule().Resources["test_instance.foo"].Primary 490 if !reflect.DeepEqual(actual, expected) { 491 t.Fatalf("bad: %#v", actual) 492 } 493 } 494 495 func TestRefresh_futureState(t *testing.T) { 496 cwd, err := os.Getwd() 497 if err != nil { 498 t.Fatalf("err: %s", err) 499 } 500 if err := os.Chdir(testFixturePath("refresh")); err != nil { 501 t.Fatalf("err: %s", err) 502 } 503 defer os.Chdir(cwd) 504 505 state := testState() 506 state.TFVersion = "99.99.99" 507 statePath := testStateFile(t, state) 508 509 p := testProvider() 510 ui := new(cli.MockUi) 511 c := &RefreshCommand{ 512 Meta: Meta{ 513 ContextOpts: testCtxConfig(p), 514 Ui: ui, 515 }, 516 } 517 518 args := []string{ 519 "-state", statePath, 520 } 521 if code := c.Run(args); code == 0 { 522 t.Fatal("should fail") 523 } 524 525 if p.RefreshCalled { 526 t.Fatal("refresh should not be called") 527 } 528 529 f, err := os.Open(statePath) 530 if err != nil { 531 t.Fatalf("err: %s", err) 532 } 533 534 newState, err := terraform.ReadState(f) 535 f.Close() 536 if err != nil { 537 t.Fatalf("err: %s", err) 538 } 539 540 actual := strings.TrimSpace(newState.String()) 541 expected := strings.TrimSpace(state.String()) 542 if actual != expected { 543 t.Fatalf("bad:\n\n%s", actual) 544 } 545 } 546 547 func TestRefresh_pastState(t *testing.T) { 548 state := testState() 549 state.TFVersion = "0.1.0" 550 statePath := testStateFile(t, state) 551 552 p := testProvider() 553 ui := new(cli.MockUi) 554 c := &RefreshCommand{ 555 Meta: Meta{ 556 ContextOpts: testCtxConfig(p), 557 Ui: ui, 558 }, 559 } 560 561 p.RefreshFn = nil 562 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 563 564 args := []string{ 565 "-state", statePath, 566 testFixturePath("refresh"), 567 } 568 if code := c.Run(args); code != 0 { 569 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 570 } 571 572 if !p.RefreshCalled { 573 t.Fatal("refresh should be called") 574 } 575 576 f, err := os.Open(statePath) 577 if err != nil { 578 t.Fatalf("err: %s", err) 579 } 580 581 newState, err := terraform.ReadState(f) 582 f.Close() 583 if err != nil { 584 t.Fatalf("err: %s", err) 585 } 586 587 actual := strings.TrimSpace(newState.String()) 588 expected := strings.TrimSpace(testRefreshStr) 589 if actual != expected { 590 t.Fatalf("bad:\n\n%s", actual) 591 } 592 593 if newState.TFVersion != terraform.Version { 594 t.Fatalf("bad:\n\n%s", newState.TFVersion) 595 } 596 } 597 598 func TestRefresh_outPath(t *testing.T) { 599 state := testState() 600 statePath := testStateFile(t, state) 601 602 // Output path 603 outf, err := ioutil.TempFile("", "tf") 604 if err != nil { 605 t.Fatalf("err: %s", err) 606 } 607 outPath := outf.Name() 608 outf.Close() 609 os.Remove(outPath) 610 611 p := testProvider() 612 ui := new(cli.MockUi) 613 c := &RefreshCommand{ 614 Meta: Meta{ 615 ContextOpts: testCtxConfig(p), 616 Ui: ui, 617 }, 618 } 619 620 p.RefreshFn = nil 621 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 622 623 args := []string{ 624 "-state", statePath, 625 "-state-out", outPath, 626 testFixturePath("refresh"), 627 } 628 if code := c.Run(args); code != 0 { 629 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 630 } 631 632 f, err := os.Open(statePath) 633 if err != nil { 634 t.Fatalf("err: %s", err) 635 } 636 637 newState, err := terraform.ReadState(f) 638 f.Close() 639 if err != nil { 640 t.Fatalf("err: %s", err) 641 } 642 643 if !reflect.DeepEqual(newState, state) { 644 t.Fatalf("bad: %#v", newState) 645 } 646 647 f, err = os.Open(outPath) 648 if err != nil { 649 t.Fatalf("err: %s", err) 650 } 651 652 newState, err = terraform.ReadState(f) 653 f.Close() 654 if err != nil { 655 t.Fatalf("err: %s", err) 656 } 657 658 actual := newState.RootModule().Resources["test_instance.foo"].Primary 659 expected := p.RefreshReturn 660 if !reflect.DeepEqual(actual, expected) { 661 t.Fatalf("bad: %#v", actual) 662 } 663 664 f, err = os.Open(outPath + DefaultBackupExtension) 665 if err != nil { 666 t.Fatalf("err: %s", err) 667 } 668 669 backupState, err := terraform.ReadState(f) 670 f.Close() 671 if err != nil { 672 t.Fatalf("err: %s", err) 673 } 674 675 actualStr := strings.TrimSpace(backupState.String()) 676 expectedStr := strings.TrimSpace(state.String()) 677 if actualStr != expectedStr { 678 t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr) 679 } 680 } 681 682 func TestRefresh_var(t *testing.T) { 683 state := testState() 684 statePath := testStateFile(t, state) 685 686 p := testProvider() 687 ui := new(cli.MockUi) 688 c := &RefreshCommand{ 689 Meta: Meta{ 690 ContextOpts: testCtxConfig(p), 691 Ui: ui, 692 }, 693 } 694 695 args := []string{ 696 "-var", "foo=bar", 697 "-state", statePath, 698 testFixturePath("refresh-var"), 699 } 700 if code := c.Run(args); code != 0 { 701 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 702 } 703 704 if !p.ConfigureCalled { 705 t.Fatal("configure should be called") 706 } 707 if p.ConfigureConfig.Config["value"].(string) != "bar" { 708 t.Fatalf("bad: %#v", p.ConfigureConfig.Config) 709 } 710 } 711 712 func TestRefresh_varFile(t *testing.T) { 713 state := testState() 714 statePath := testStateFile(t, state) 715 716 p := testProvider() 717 ui := new(cli.MockUi) 718 c := &RefreshCommand{ 719 Meta: Meta{ 720 ContextOpts: testCtxConfig(p), 721 Ui: ui, 722 }, 723 } 724 725 varFilePath := testTempFile(t) 726 if err := ioutil.WriteFile(varFilePath, []byte(refreshVarFile), 0644); err != nil { 727 t.Fatalf("err: %s", err) 728 } 729 730 args := []string{ 731 "-var-file", varFilePath, 732 "-state", statePath, 733 testFixturePath("refresh-var"), 734 } 735 if code := c.Run(args); code != 0 { 736 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 737 } 738 739 if !p.ConfigureCalled { 740 t.Fatal("configure should be called") 741 } 742 if p.ConfigureConfig.Config["value"].(string) != "bar" { 743 t.Fatalf("bad: %#v", p.ConfigureConfig.Config) 744 } 745 } 746 747 func TestRefresh_varFileDefault(t *testing.T) { 748 state := testState() 749 statePath := testStateFile(t, state) 750 751 p := testProvider() 752 ui := new(cli.MockUi) 753 c := &RefreshCommand{ 754 Meta: Meta{ 755 ContextOpts: testCtxConfig(p), 756 Ui: ui, 757 }, 758 } 759 760 varFileDir := testTempDir(t) 761 varFilePath := filepath.Join(varFileDir, "terraform.tfvars") 762 if err := ioutil.WriteFile(varFilePath, []byte(refreshVarFile), 0644); err != nil { 763 t.Fatalf("err: %s", err) 764 } 765 766 cwd, err := os.Getwd() 767 if err != nil { 768 t.Fatalf("err: %s", err) 769 } 770 if err := os.Chdir(varFileDir); err != nil { 771 t.Fatalf("err: %s", err) 772 } 773 defer os.Chdir(cwd) 774 775 args := []string{ 776 "-state", statePath, 777 testFixturePath("refresh-var"), 778 } 779 if code := c.Run(args); code != 0 { 780 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 781 } 782 783 if !p.ConfigureCalled { 784 t.Fatal("configure should be called") 785 } 786 if p.ConfigureConfig.Config["value"].(string) != "bar" { 787 t.Fatalf("bad: %#v", p.ConfigureConfig.Config) 788 } 789 } 790 791 func TestRefresh_varsUnset(t *testing.T) { 792 // Disable test mode so input would be asked 793 test = false 794 defer func() { test = true }() 795 796 defaultInputReader = bytes.NewBufferString("bar\n") 797 798 state := testState() 799 statePath := testStateFile(t, state) 800 801 p := testProvider() 802 ui := new(cli.MockUi) 803 c := &RefreshCommand{ 804 Meta: Meta{ 805 ContextOpts: testCtxConfig(p), 806 Ui: ui, 807 }, 808 } 809 810 args := []string{ 811 "-state", statePath, 812 testFixturePath("refresh-unset-var"), 813 } 814 if code := c.Run(args); code != 0 { 815 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 816 } 817 } 818 819 func TestRefresh_backup(t *testing.T) { 820 state := testState() 821 statePath := testStateFile(t, state) 822 823 // Output path 824 outf, err := ioutil.TempFile("", "tf") 825 if err != nil { 826 t.Fatalf("err: %s", err) 827 } 828 outPath := outf.Name() 829 outf.Close() 830 os.Remove(outPath) 831 832 // Backup path 833 backupf, err := ioutil.TempFile("", "tf") 834 if err != nil { 835 t.Fatalf("err: %s", err) 836 } 837 backupPath := backupf.Name() 838 backupf.Close() 839 os.Remove(backupPath) 840 841 p := testProvider() 842 ui := new(cli.MockUi) 843 c := &RefreshCommand{ 844 Meta: Meta{ 845 ContextOpts: testCtxConfig(p), 846 Ui: ui, 847 }, 848 } 849 850 p.RefreshFn = nil 851 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 852 853 args := []string{ 854 "-state", statePath, 855 "-state-out", outPath, 856 "-backup", backupPath, 857 testFixturePath("refresh"), 858 } 859 if code := c.Run(args); code != 0 { 860 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 861 } 862 863 f, err := os.Open(statePath) 864 if err != nil { 865 t.Fatalf("err: %s", err) 866 } 867 868 newState, err := terraform.ReadState(f) 869 f.Close() 870 if err != nil { 871 t.Fatalf("err: %s", err) 872 } 873 874 if !reflect.DeepEqual(newState, state) { 875 t.Fatalf("bad: %#v", newState) 876 } 877 878 f, err = os.Open(outPath) 879 if err != nil { 880 t.Fatalf("err: %s", err) 881 } 882 883 newState, err = terraform.ReadState(f) 884 f.Close() 885 if err != nil { 886 t.Fatalf("err: %s", err) 887 } 888 889 actual := newState.RootModule().Resources["test_instance.foo"].Primary 890 expected := p.RefreshReturn 891 if !reflect.DeepEqual(actual, expected) { 892 t.Fatalf("bad: %#v", actual) 893 } 894 895 f, err = os.Open(backupPath) 896 if err != nil { 897 t.Fatalf("err: %s", err) 898 } 899 900 backupState, err := terraform.ReadState(f) 901 f.Close() 902 if err != nil { 903 t.Fatalf("err: %s", err) 904 } 905 906 actualStr := strings.TrimSpace(backupState.String()) 907 expectedStr := strings.TrimSpace(state.String()) 908 if actualStr != expectedStr { 909 t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr) 910 } 911 } 912 913 func TestRefresh_disableBackup(t *testing.T) { 914 state := testState() 915 statePath := testStateFile(t, state) 916 917 // Output path 918 outf, err := ioutil.TempFile("", "tf") 919 if err != nil { 920 t.Fatalf("err: %s", err) 921 } 922 outPath := outf.Name() 923 outf.Close() 924 os.Remove(outPath) 925 926 p := testProvider() 927 ui := new(cli.MockUi) 928 c := &RefreshCommand{ 929 Meta: Meta{ 930 ContextOpts: testCtxConfig(p), 931 Ui: ui, 932 }, 933 } 934 935 p.RefreshFn = nil 936 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 937 938 args := []string{ 939 "-state", statePath, 940 "-state-out", outPath, 941 "-backup", "-", 942 testFixturePath("refresh"), 943 } 944 if code := c.Run(args); code != 0 { 945 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 946 } 947 948 f, err := os.Open(statePath) 949 if err != nil { 950 t.Fatalf("err: %s", err) 951 } 952 953 newState, err := terraform.ReadState(f) 954 f.Close() 955 if err != nil { 956 t.Fatalf("err: %s", err) 957 } 958 959 if !reflect.DeepEqual(newState, state) { 960 t.Fatalf("bad: %#v", newState) 961 } 962 963 f, err = os.Open(outPath) 964 if err != nil { 965 t.Fatalf("err: %s", err) 966 } 967 968 newState, err = terraform.ReadState(f) 969 f.Close() 970 if err != nil { 971 t.Fatalf("err: %s", err) 972 } 973 974 actual := newState.RootModule().Resources["test_instance.foo"].Primary 975 expected := p.RefreshReturn 976 if !reflect.DeepEqual(actual, expected) { 977 t.Fatalf("bad: %#v", actual) 978 } 979 980 // Ensure there is no backup 981 _, err = os.Stat(outPath + DefaultBackupExtension) 982 if err == nil || !os.IsNotExist(err) { 983 t.Fatalf("backup should not exist") 984 } 985 } 986 987 func TestRefresh_displaysOutputs(t *testing.T) { 988 state := testState() 989 statePath := testStateFile(t, state) 990 991 p := testProvider() 992 ui := new(cli.MockUi) 993 c := &RefreshCommand{ 994 Meta: Meta{ 995 ContextOpts: testCtxConfig(p), 996 Ui: ui, 997 }, 998 } 999 1000 args := []string{ 1001 "-state", statePath, 1002 testFixturePath("refresh-output"), 1003 } 1004 if code := c.Run(args); code != 0 { 1005 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 1006 } 1007 1008 // Test that outputs were displayed 1009 outputValue := "foo.example.com" 1010 actual := ui.OutputWriter.String() 1011 if !strings.Contains(actual, outputValue) { 1012 t.Fatalf("Expected:\n%s\n\nTo include: %q", actual, outputValue) 1013 } 1014 } 1015 */ 1016 1017 func TestImport_customProvider(t *testing.T) { 1018 statePath := testTempFile(t) 1019 1020 p := testProvider() 1021 ui := new(cli.MockUi) 1022 c := &ImportCommand{ 1023 Meta: Meta{ 1024 ContextOpts: testCtxConfig(p), 1025 Ui: ui, 1026 }, 1027 } 1028 1029 p.ImportStateFn = nil 1030 p.ImportStateReturn = []*terraform.InstanceState{ 1031 &terraform.InstanceState{ 1032 ID: "yay", 1033 Ephemeral: terraform.EphemeralState{ 1034 Type: "test_instance", 1035 }, 1036 }, 1037 } 1038 1039 args := []string{ 1040 "-provider", "test.alias", 1041 "-state", statePath, 1042 "test_instance.foo", 1043 "bar", 1044 } 1045 if code := c.Run(args); code != 0 { 1046 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 1047 } 1048 1049 if !p.ImportStateCalled { 1050 t.Fatal("ImportState should be called") 1051 } 1052 1053 testStateOutput(t, statePath, testImportCustomProviderStr) 1054 } 1055 1056 const testImportStr = ` 1057 test_instance.foo: 1058 ID = yay 1059 provider = test 1060 ` 1061 1062 const testImportCustomProviderStr = ` 1063 test_instance.foo: 1064 ID = yay 1065 provider = test.alias 1066 `