github.com/serbaut/terraform@v0.6.12-0.20160607213102-ac2d195cc560/terraform/context_refresh_test.go (about) 1 package terraform 2 3 import ( 4 "reflect" 5 "sort" 6 "strings" 7 "sync" 8 "testing" 9 ) 10 11 func TestContext2Refresh(t *testing.T) { 12 p := testProvider("aws") 13 m := testModule(t, "refresh-basic") 14 ctx := testContext2(t, &ContextOpts{ 15 Module: m, 16 Providers: map[string]ResourceProviderFactory{ 17 "aws": testProviderFuncFixed(p), 18 }, 19 State: &State{ 20 Modules: []*ModuleState{ 21 &ModuleState{ 22 Path: rootModulePath, 23 Resources: map[string]*ResourceState{ 24 "aws_instance.web": &ResourceState{ 25 Type: "aws_instance", 26 Primary: &InstanceState{ 27 ID: "foo", 28 }, 29 }, 30 }, 31 }, 32 }, 33 }, 34 }) 35 36 p.RefreshFn = nil 37 p.RefreshReturn = &InstanceState{ 38 ID: "foo", 39 } 40 41 s, err := ctx.Refresh() 42 mod := s.RootModule() 43 if err != nil { 44 t.Fatalf("err: %s", err) 45 } 46 if !p.RefreshCalled { 47 t.Fatal("refresh should be called") 48 } 49 if p.RefreshState.ID != "foo" { 50 t.Fatalf("bad: %#v", p.RefreshState) 51 } 52 if !reflect.DeepEqual(mod.Resources["aws_instance.web"].Primary, p.RefreshReturn) { 53 t.Fatalf("bad: %#v %#v", mod.Resources["aws_instance.web"], p.RefreshReturn) 54 } 55 56 for _, r := range mod.Resources { 57 if r.Type == "" { 58 t.Fatalf("no type: %#v", r) 59 } 60 } 61 } 62 63 func TestContext2Refresh_targeted(t *testing.T) { 64 p := testProvider("aws") 65 m := testModule(t, "refresh-targeted") 66 ctx := testContext2(t, &ContextOpts{ 67 Module: m, 68 Providers: map[string]ResourceProviderFactory{ 69 "aws": testProviderFuncFixed(p), 70 }, 71 State: &State{ 72 Modules: []*ModuleState{ 73 &ModuleState{ 74 Path: rootModulePath, 75 Resources: map[string]*ResourceState{ 76 "aws_vpc.metoo": resourceState("aws_vpc", "vpc-abc123"), 77 "aws_instance.notme": resourceState("aws_instance", "i-bcd345"), 78 "aws_instance.me": resourceState("aws_instance", "i-abc123"), 79 "aws_elb.meneither": resourceState("aws_elb", "lb-abc123"), 80 }, 81 }, 82 }, 83 }, 84 Targets: []string{"aws_instance.me"}, 85 }) 86 87 refreshedResources := make([]string, 0, 2) 88 p.RefreshFn = func(i *InstanceInfo, is *InstanceState) (*InstanceState, error) { 89 refreshedResources = append(refreshedResources, i.Id) 90 return is, nil 91 } 92 93 _, err := ctx.Refresh() 94 if err != nil { 95 t.Fatalf("err: %s", err) 96 } 97 98 expected := []string{"aws_vpc.metoo", "aws_instance.me"} 99 if !reflect.DeepEqual(refreshedResources, expected) { 100 t.Fatalf("expected: %#v, got: %#v", expected, refreshedResources) 101 } 102 } 103 104 func TestContext2Refresh_targetedCount(t *testing.T) { 105 p := testProvider("aws") 106 m := testModule(t, "refresh-targeted-count") 107 ctx := testContext2(t, &ContextOpts{ 108 Module: m, 109 Providers: map[string]ResourceProviderFactory{ 110 "aws": testProviderFuncFixed(p), 111 }, 112 State: &State{ 113 Modules: []*ModuleState{ 114 &ModuleState{ 115 Path: rootModulePath, 116 Resources: map[string]*ResourceState{ 117 "aws_vpc.metoo": resourceState("aws_vpc", "vpc-abc123"), 118 "aws_instance.notme": resourceState("aws_instance", "i-bcd345"), 119 "aws_instance.me.0": resourceState("aws_instance", "i-abc123"), 120 "aws_instance.me.1": resourceState("aws_instance", "i-cde567"), 121 "aws_instance.me.2": resourceState("aws_instance", "i-cde789"), 122 "aws_elb.meneither": resourceState("aws_elb", "lb-abc123"), 123 }, 124 }, 125 }, 126 }, 127 Targets: []string{"aws_instance.me"}, 128 }) 129 130 refreshedResources := make([]string, 0, 2) 131 p.RefreshFn = func(i *InstanceInfo, is *InstanceState) (*InstanceState, error) { 132 refreshedResources = append(refreshedResources, i.Id) 133 return is, nil 134 } 135 136 _, err := ctx.Refresh() 137 if err != nil { 138 t.Fatalf("err: %s", err) 139 } 140 141 // Target didn't specify index, so we should get all our instances 142 expected := []string{ 143 "aws_vpc.metoo", 144 "aws_instance.me.0", 145 "aws_instance.me.1", 146 "aws_instance.me.2", 147 } 148 sort.Strings(expected) 149 sort.Strings(refreshedResources) 150 if !reflect.DeepEqual(refreshedResources, expected) { 151 t.Fatalf("expected: %#v, got: %#v", expected, refreshedResources) 152 } 153 } 154 155 func TestContext2Refresh_targetedCountIndex(t *testing.T) { 156 p := testProvider("aws") 157 m := testModule(t, "refresh-targeted-count") 158 ctx := testContext2(t, &ContextOpts{ 159 Module: m, 160 Providers: map[string]ResourceProviderFactory{ 161 "aws": testProviderFuncFixed(p), 162 }, 163 State: &State{ 164 Modules: []*ModuleState{ 165 &ModuleState{ 166 Path: rootModulePath, 167 Resources: map[string]*ResourceState{ 168 "aws_vpc.metoo": resourceState("aws_vpc", "vpc-abc123"), 169 "aws_instance.notme": resourceState("aws_instance", "i-bcd345"), 170 "aws_instance.me.0": resourceState("aws_instance", "i-abc123"), 171 "aws_instance.me.1": resourceState("aws_instance", "i-cde567"), 172 "aws_instance.me.2": resourceState("aws_instance", "i-cde789"), 173 "aws_elb.meneither": resourceState("aws_elb", "lb-abc123"), 174 }, 175 }, 176 }, 177 }, 178 Targets: []string{"aws_instance.me[0]"}, 179 }) 180 181 refreshedResources := make([]string, 0, 2) 182 p.RefreshFn = func(i *InstanceInfo, is *InstanceState) (*InstanceState, error) { 183 refreshedResources = append(refreshedResources, i.Id) 184 return is, nil 185 } 186 187 _, err := ctx.Refresh() 188 if err != nil { 189 t.Fatalf("err: %s", err) 190 } 191 192 expected := []string{"aws_vpc.metoo", "aws_instance.me.0"} 193 if !reflect.DeepEqual(refreshedResources, expected) { 194 t.Fatalf("expected: %#v, got: %#v", expected, refreshedResources) 195 } 196 } 197 198 func TestContext2Refresh_moduleComputedVar(t *testing.T) { 199 p := testProvider("aws") 200 m := testModule(t, "refresh-module-computed-var") 201 ctx := testContext2(t, &ContextOpts{ 202 Module: m, 203 Providers: map[string]ResourceProviderFactory{ 204 "aws": testProviderFuncFixed(p), 205 }, 206 }) 207 208 // This was failing (see GH-2188) at some point, so this test just 209 // verifies that the failure goes away. 210 if _, err := ctx.Refresh(); err != nil { 211 t.Fatalf("err: %s", err) 212 } 213 } 214 215 func TestContext2Refresh_delete(t *testing.T) { 216 p := testProvider("aws") 217 m := testModule(t, "refresh-basic") 218 ctx := testContext2(t, &ContextOpts{ 219 Module: m, 220 Providers: map[string]ResourceProviderFactory{ 221 "aws": testProviderFuncFixed(p), 222 }, 223 State: &State{ 224 Modules: []*ModuleState{ 225 &ModuleState{ 226 Path: rootModulePath, 227 Resources: map[string]*ResourceState{ 228 "aws_instance.web": &ResourceState{ 229 Type: "aws_instance", 230 Primary: &InstanceState{ 231 ID: "foo", 232 }, 233 }, 234 }, 235 }, 236 }, 237 }, 238 }) 239 240 p.RefreshFn = nil 241 p.RefreshReturn = nil 242 243 s, err := ctx.Refresh() 244 if err != nil { 245 t.Fatalf("err: %s", err) 246 } 247 248 mod := s.RootModule() 249 if len(mod.Resources) > 0 { 250 t.Fatal("resources should be empty") 251 } 252 } 253 254 func TestContext2Refresh_ignoreUncreated(t *testing.T) { 255 p := testProvider("aws") 256 m := testModule(t, "refresh-basic") 257 ctx := testContext2(t, &ContextOpts{ 258 Module: m, 259 Providers: map[string]ResourceProviderFactory{ 260 "aws": testProviderFuncFixed(p), 261 }, 262 State: nil, 263 }) 264 265 p.RefreshFn = nil 266 p.RefreshReturn = &InstanceState{ 267 ID: "foo", 268 } 269 270 _, err := ctx.Refresh() 271 if err != nil { 272 t.Fatalf("err: %s", err) 273 } 274 if p.RefreshCalled { 275 t.Fatal("refresh should not be called") 276 } 277 } 278 279 func TestContext2Refresh_hook(t *testing.T) { 280 h := new(MockHook) 281 p := testProvider("aws") 282 m := testModule(t, "refresh-basic") 283 ctx := testContext2(t, &ContextOpts{ 284 Module: m, 285 Hooks: []Hook{h}, 286 Providers: map[string]ResourceProviderFactory{ 287 "aws": testProviderFuncFixed(p), 288 }, 289 State: &State{ 290 Modules: []*ModuleState{ 291 &ModuleState{ 292 Path: rootModulePath, 293 Resources: map[string]*ResourceState{ 294 "aws_instance.web": &ResourceState{ 295 Type: "aws_instance", 296 Primary: &InstanceState{ 297 ID: "foo", 298 }, 299 }, 300 }, 301 }, 302 }, 303 }, 304 }) 305 306 if _, err := ctx.Refresh(); err != nil { 307 t.Fatalf("err: %s", err) 308 } 309 if !h.PreRefreshCalled { 310 t.Fatal("should be called") 311 } 312 if !h.PostRefreshCalled { 313 t.Fatal("should be called") 314 } 315 } 316 317 func TestContext2Refresh_modules(t *testing.T) { 318 p := testProvider("aws") 319 m := testModule(t, "refresh-modules") 320 state := &State{ 321 Modules: []*ModuleState{ 322 &ModuleState{ 323 Path: rootModulePath, 324 Resources: map[string]*ResourceState{ 325 "aws_instance.web": &ResourceState{ 326 Type: "aws_instance", 327 Primary: &InstanceState{ 328 ID: "bar", 329 Tainted: true, 330 }, 331 }, 332 }, 333 }, 334 335 &ModuleState{ 336 Path: []string{"root", "child"}, 337 Resources: map[string]*ResourceState{ 338 "aws_instance.web": &ResourceState{ 339 Type: "aws_instance", 340 Primary: &InstanceState{ 341 ID: "baz", 342 }, 343 }, 344 }, 345 }, 346 }, 347 } 348 ctx := testContext2(t, &ContextOpts{ 349 Module: m, 350 Providers: map[string]ResourceProviderFactory{ 351 "aws": testProviderFuncFixed(p), 352 }, 353 State: state, 354 }) 355 356 p.RefreshFn = func(info *InstanceInfo, s *InstanceState) (*InstanceState, error) { 357 if s.ID != "baz" { 358 return s, nil 359 } 360 361 s.ID = "new" 362 return s, nil 363 } 364 365 s, err := ctx.Refresh() 366 if err != nil { 367 t.Fatalf("err: %s", err) 368 } 369 370 actual := strings.TrimSpace(s.String()) 371 expected := strings.TrimSpace(testContextRefreshModuleStr) 372 if actual != expected { 373 t.Fatalf("bad:\n\n%s\n\n%s", actual, expected) 374 } 375 } 376 377 func TestContext2Refresh_moduleInputComputedOutput(t *testing.T) { 378 m := testModule(t, "refresh-module-input-computed-output") 379 p := testProvider("aws") 380 p.DiffFn = testDiffFn 381 ctx := testContext2(t, &ContextOpts{ 382 Module: m, 383 Providers: map[string]ResourceProviderFactory{ 384 "aws": testProviderFuncFixed(p), 385 }, 386 }) 387 388 if _, err := ctx.Refresh(); err != nil { 389 t.Fatalf("err: %s", err) 390 } 391 } 392 393 func TestContext2Refresh_moduleVarModule(t *testing.T) { 394 m := testModule(t, "refresh-module-var-module") 395 p := testProvider("aws") 396 p.DiffFn = testDiffFn 397 ctx := testContext2(t, &ContextOpts{ 398 Module: m, 399 Providers: map[string]ResourceProviderFactory{ 400 "aws": testProviderFuncFixed(p), 401 }, 402 }) 403 404 if _, err := ctx.Refresh(); err != nil { 405 t.Fatalf("err: %s", err) 406 } 407 } 408 409 // GH-70 410 func TestContext2Refresh_noState(t *testing.T) { 411 p := testProvider("aws") 412 m := testModule(t, "refresh-no-state") 413 ctx := testContext2(t, &ContextOpts{ 414 Module: m, 415 Providers: map[string]ResourceProviderFactory{ 416 "aws": testProviderFuncFixed(p), 417 }, 418 }) 419 420 p.RefreshFn = nil 421 p.RefreshReturn = &InstanceState{ 422 ID: "foo", 423 } 424 425 if _, err := ctx.Refresh(); err != nil { 426 t.Fatalf("err: %s", err) 427 } 428 } 429 430 func TestContext2Refresh_output(t *testing.T) { 431 p := testProvider("aws") 432 m := testModule(t, "refresh-output") 433 ctx := testContext2(t, &ContextOpts{ 434 Module: m, 435 Providers: map[string]ResourceProviderFactory{ 436 "aws": testProviderFuncFixed(p), 437 }, 438 State: &State{ 439 Modules: []*ModuleState{ 440 &ModuleState{ 441 Path: rootModulePath, 442 Resources: map[string]*ResourceState{ 443 "aws_instance.web": &ResourceState{ 444 Type: "aws_instance", 445 Primary: &InstanceState{ 446 ID: "foo", 447 Attributes: map[string]string{ 448 "foo": "bar", 449 }, 450 }, 451 }, 452 }, 453 454 Outputs: map[string]*OutputState{ 455 "foo": &OutputState{ 456 Type: "string", 457 Sensitive: false, 458 Value: "foo", 459 }, 460 }, 461 }, 462 }, 463 }, 464 }) 465 466 p.RefreshFn = func(info *InstanceInfo, s *InstanceState) (*InstanceState, error) { 467 return s, nil 468 } 469 470 s, err := ctx.Refresh() 471 if err != nil { 472 t.Fatalf("err: %s", err) 473 } 474 475 actual := strings.TrimSpace(s.String()) 476 expected := strings.TrimSpace(testContextRefreshOutputStr) 477 if actual != expected { 478 t.Fatalf("bad:\n\n%s\n\n%s", actual, expected) 479 } 480 } 481 482 func TestContext2Refresh_outputPartial(t *testing.T) { 483 p := testProvider("aws") 484 m := testModule(t, "refresh-output-partial") 485 ctx := testContext2(t, &ContextOpts{ 486 Module: m, 487 Providers: map[string]ResourceProviderFactory{ 488 "aws": testProviderFuncFixed(p), 489 }, 490 State: &State{ 491 Modules: []*ModuleState{ 492 &ModuleState{ 493 Path: rootModulePath, 494 Resources: map[string]*ResourceState{ 495 "aws_instance.foo": &ResourceState{ 496 Type: "aws_instance", 497 Primary: &InstanceState{ 498 ID: "foo", 499 }, 500 }, 501 }, 502 }, 503 }, 504 }, 505 }) 506 507 p.RefreshFn = nil 508 p.RefreshReturn = nil 509 510 s, err := ctx.Refresh() 511 if err != nil { 512 t.Fatalf("err: %s", err) 513 } 514 515 actual := strings.TrimSpace(s.String()) 516 expected := strings.TrimSpace(testContextRefreshOutputPartialStr) 517 if actual != expected { 518 t.Fatalf("bad:\n\n%s\n\n%s", actual, expected) 519 } 520 } 521 522 func TestContext2Refresh_state(t *testing.T) { 523 p := testProvider("aws") 524 m := testModule(t, "refresh-basic") 525 state := &State{ 526 Modules: []*ModuleState{ 527 &ModuleState{ 528 Path: rootModulePath, 529 Resources: map[string]*ResourceState{ 530 "aws_instance.web": &ResourceState{ 531 Primary: &InstanceState{ 532 ID: "bar", 533 }, 534 }, 535 }, 536 }, 537 }, 538 } 539 ctx := testContext2(t, &ContextOpts{ 540 Module: m, 541 Providers: map[string]ResourceProviderFactory{ 542 "aws": testProviderFuncFixed(p), 543 }, 544 State: state, 545 }) 546 547 p.RefreshFn = nil 548 p.RefreshReturn = &InstanceState{ 549 ID: "foo", 550 } 551 552 s, err := ctx.Refresh() 553 if err != nil { 554 t.Fatalf("err: %s", err) 555 } 556 originalMod := state.RootModule() 557 mod := s.RootModule() 558 if !p.RefreshCalled { 559 t.Fatal("refresh should be called") 560 } 561 if !reflect.DeepEqual(p.RefreshState, originalMod.Resources["aws_instance.web"].Primary) { 562 t.Fatalf( 563 "bad:\n\n%#v\n\n%#v", 564 p.RefreshState, 565 originalMod.Resources["aws_instance.web"].Primary) 566 } 567 if !reflect.DeepEqual(mod.Resources["aws_instance.web"].Primary, p.RefreshReturn) { 568 t.Fatalf("bad: %#v", mod.Resources) 569 } 570 } 571 572 func TestContext2Refresh_dataState(t *testing.T) { 573 p := testProvider("null") 574 m := testModule(t, "refresh-data-resource-basic") 575 state := &State{ 576 Modules: []*ModuleState{ 577 &ModuleState{ 578 Path: rootModulePath, 579 // Intentionally no resources since data resources are 580 // supposed to refresh themselves even if they didn't 581 // already exist. 582 Resources: map[string]*ResourceState{}, 583 }, 584 }, 585 } 586 ctx := testContext2(t, &ContextOpts{ 587 Module: m, 588 Providers: map[string]ResourceProviderFactory{ 589 "null": testProviderFuncFixed(p), 590 }, 591 State: state, 592 }) 593 594 p.ReadDataDiffFn = nil 595 p.ReadDataDiffReturn = &InstanceDiff{ 596 Attributes: map[string]*ResourceAttrDiff{ 597 "inputs.#": { 598 Old: "0", 599 New: "1", 600 Type: DiffAttrInput, 601 }, 602 "inputs.test": { 603 Old: "", 604 New: "yes", 605 Type: DiffAttrInput, 606 }, 607 "outputs.#": { 608 Old: "", 609 New: "", 610 NewComputed: true, 611 Type: DiffAttrOutput, 612 }, 613 }, 614 } 615 616 p.ReadDataApplyFn = nil 617 p.ReadDataApplyReturn = &InstanceState{ 618 ID: "-", 619 } 620 621 s, err := ctx.Refresh() 622 if err != nil { 623 t.Fatalf("err: %s", err) 624 } 625 626 if !p.ReadDataDiffCalled { 627 t.Fatal("ReadDataDiff should have been called") 628 } 629 if !p.ReadDataApplyCalled { 630 t.Fatal("ReadDataApply should have been called") 631 } 632 633 mod := s.RootModule() 634 if got := mod.Resources["data.null_data_source.testing"].Primary.ID; got != "-" { 635 t.Fatalf("resource id is %q; want %s", got, "-") 636 } 637 if !reflect.DeepEqual(mod.Resources["data.null_data_source.testing"].Primary, p.ReadDataApplyReturn) { 638 t.Fatalf("bad: %#v", mod.Resources) 639 } 640 } 641 642 func TestContext2Refresh_tainted(t *testing.T) { 643 p := testProvider("aws") 644 m := testModule(t, "refresh-basic") 645 state := &State{ 646 Modules: []*ModuleState{ 647 &ModuleState{ 648 Path: rootModulePath, 649 Resources: map[string]*ResourceState{ 650 "aws_instance.web": &ResourceState{ 651 Type: "aws_instance", 652 Primary: &InstanceState{ 653 ID: "bar", 654 Tainted: true, 655 }, 656 }, 657 }, 658 }, 659 }, 660 } 661 ctx := testContext2(t, &ContextOpts{ 662 Module: m, 663 Providers: map[string]ResourceProviderFactory{ 664 "aws": testProviderFuncFixed(p), 665 }, 666 State: state, 667 }) 668 669 p.RefreshFn = nil 670 p.RefreshReturn = &InstanceState{ 671 ID: "foo", 672 Tainted: true, 673 } 674 675 s, err := ctx.Refresh() 676 if err != nil { 677 t.Fatalf("err: %s", err) 678 } 679 if !p.RefreshCalled { 680 t.Fatal("refresh should be called") 681 } 682 683 actual := strings.TrimSpace(s.String()) 684 expected := strings.TrimSpace(testContextRefreshTaintedStr) 685 if actual != expected { 686 t.Fatalf("bad:\n\n%s\n\n%s", actual, expected) 687 } 688 } 689 690 // Doing a Refresh (or any operation really, but Refresh usually 691 // happens first) with a config with an unknown provider should result in 692 // an error. The key bug this found was that this wasn't happening if 693 // Providers was _empty_. 694 func TestContext2Refresh_unknownProvider(t *testing.T) { 695 m := testModule(t, "refresh-unknown-provider") 696 p := testProvider("aws") 697 p.ApplyFn = testApplyFn 698 p.DiffFn = testDiffFn 699 ctx := testContext2(t, &ContextOpts{ 700 Module: m, 701 Providers: map[string]ResourceProviderFactory{}, 702 }) 703 704 if _, err := ctx.Refresh(); err == nil { 705 t.Fatal("should error") 706 } 707 } 708 709 func TestContext2Refresh_vars(t *testing.T) { 710 p := testProvider("aws") 711 m := testModule(t, "refresh-vars") 712 ctx := testContext2(t, &ContextOpts{ 713 Module: m, 714 Providers: map[string]ResourceProviderFactory{ 715 "aws": testProviderFuncFixed(p), 716 }, 717 State: &State{ 718 719 Modules: []*ModuleState{ 720 &ModuleState{ 721 Path: rootModulePath, 722 Resources: map[string]*ResourceState{ 723 "aws_instance.web": &ResourceState{ 724 Type: "aws_instance", 725 Primary: &InstanceState{ 726 ID: "foo", 727 }, 728 }, 729 }, 730 }, 731 }, 732 }, 733 }) 734 735 p.RefreshFn = nil 736 p.RefreshReturn = &InstanceState{ 737 ID: "foo", 738 } 739 740 s, err := ctx.Refresh() 741 if err != nil { 742 t.Fatalf("err: %s", err) 743 } 744 mod := s.RootModule() 745 if !p.RefreshCalled { 746 t.Fatal("refresh should be called") 747 } 748 if p.RefreshState.ID != "foo" { 749 t.Fatalf("bad: %#v", p.RefreshState) 750 } 751 if !reflect.DeepEqual(mod.Resources["aws_instance.web"].Primary, p.RefreshReturn) { 752 t.Fatalf("bad: %#v", mod.Resources["aws_instance.web"]) 753 } 754 755 for _, r := range mod.Resources { 756 if r.Type == "" { 757 t.Fatalf("no type: %#v", r) 758 } 759 } 760 } 761 762 func TestContext2Refresh_orphanModule(t *testing.T) { 763 p := testProvider("aws") 764 m := testModule(t, "refresh-module-orphan") 765 766 // Create a custom refresh function to track the order they were visited 767 var order []string 768 var orderLock sync.Mutex 769 p.RefreshFn = func( 770 info *InstanceInfo, 771 is *InstanceState) (*InstanceState, error) { 772 orderLock.Lock() 773 defer orderLock.Unlock() 774 775 order = append(order, is.ID) 776 return is, nil 777 } 778 779 state := &State{ 780 Modules: []*ModuleState{ 781 &ModuleState{ 782 Path: rootModulePath, 783 Resources: map[string]*ResourceState{ 784 "aws_instance.foo": &ResourceState{ 785 Primary: &InstanceState{ 786 ID: "i-abc123", 787 Attributes: map[string]string{ 788 "childid": "i-bcd234", 789 "grandchildid": "i-cde345", 790 }, 791 }, 792 Dependencies: []string{ 793 "module.child", 794 "module.child", 795 }, 796 }, 797 }, 798 }, 799 &ModuleState{ 800 Path: append(rootModulePath, "child"), 801 Resources: map[string]*ResourceState{ 802 "aws_instance.bar": &ResourceState{ 803 Primary: &InstanceState{ 804 ID: "i-bcd234", 805 Attributes: map[string]string{ 806 "grandchildid": "i-cde345", 807 }, 808 }, 809 Dependencies: []string{ 810 "module.grandchild", 811 }, 812 }, 813 }, 814 Outputs: map[string]*OutputState{ 815 "id": &OutputState{ 816 Value: "i-bcd234", 817 Type: "string", 818 }, 819 "grandchild_id": &OutputState{ 820 Value: "i-cde345", 821 Type: "string", 822 }, 823 }, 824 }, 825 &ModuleState{ 826 Path: append(rootModulePath, "child", "grandchild"), 827 Resources: map[string]*ResourceState{ 828 "aws_instance.baz": &ResourceState{ 829 Primary: &InstanceState{ 830 ID: "i-cde345", 831 }, 832 }, 833 }, 834 Outputs: map[string]*OutputState{ 835 "id": &OutputState{ 836 Value: "i-cde345", 837 Type: "string", 838 }, 839 }, 840 }, 841 }, 842 } 843 ctx := testContext2(t, &ContextOpts{ 844 Module: m, 845 Providers: map[string]ResourceProviderFactory{ 846 "aws": testProviderFuncFixed(p), 847 }, 848 State: state, 849 }) 850 851 testCheckDeadlock(t, func() { 852 _, err := ctx.Refresh() 853 if err != nil { 854 t.Fatalf("err: %s", err) 855 } 856 857 // TODO: handle order properly for orphaned modules / resources 858 // expected := []string{"i-abc123", "i-bcd234", "i-cde345"} 859 // if !reflect.DeepEqual(order, expected) { 860 // t.Fatalf("expected: %#v, got: %#v", expected, order) 861 // } 862 }) 863 } 864 865 func TestContext2Validate(t *testing.T) { 866 p := testProvider("aws") 867 m := testModule(t, "validate-good") 868 c := testContext2(t, &ContextOpts{ 869 Module: m, 870 Providers: map[string]ResourceProviderFactory{ 871 "aws": testProviderFuncFixed(p), 872 }, 873 }) 874 875 w, e := c.Validate() 876 if len(w) > 0 { 877 t.Fatalf("bad: %#v", w) 878 } 879 if len(e) > 0 { 880 t.Fatalf("bad: %s", e) 881 } 882 }