github.com/pmcatominey/terraform@v0.7.0-rc2.0.20160708105029-1401a52a5cc5/terraform/context_validate_test.go (about)

     1  package terraform
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  	"testing"
     7  )
     8  
     9  func TestContext2Validate_badVar(t *testing.T) {
    10  	p := testProvider("aws")
    11  	m := testModule(t, "validate-bad-var")
    12  	c := testContext2(t, &ContextOpts{
    13  		Module: m,
    14  		Providers: map[string]ResourceProviderFactory{
    15  			"aws": testProviderFuncFixed(p),
    16  		},
    17  	})
    18  
    19  	w, e := c.Validate()
    20  	if len(w) > 0 {
    21  		t.Fatalf("bad: %#v", w)
    22  	}
    23  	if len(e) == 0 {
    24  		t.Fatalf("bad: %#v", e)
    25  	}
    26  }
    27  
    28  func TestContext2Validate_varNoDefaultExplicitType(t *testing.T) {
    29  	m := testModule(t, "validate-var-no-default-explicit-type")
    30  	c := testContext2(t, &ContextOpts{
    31  		Module: m,
    32  	})
    33  
    34  	w, e := c.Validate()
    35  	if len(w) > 0 {
    36  		t.Fatalf("bad: %#v", w)
    37  	}
    38  	if len(e) == 0 {
    39  		t.Fatalf("bad: %#v", e)
    40  	}
    41  }
    42  
    43  func TestContext2Validate_computedVar(t *testing.T) {
    44  	p := testProvider("aws")
    45  	m := testModule(t, "validate-computed-var")
    46  	c := testContext2(t, &ContextOpts{
    47  		Module: m,
    48  		Providers: map[string]ResourceProviderFactory{
    49  			"aws":  testProviderFuncFixed(p),
    50  			"test": testProviderFuncFixed(testProvider("test")),
    51  		},
    52  	})
    53  
    54  	p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
    55  		if !c.IsComputed("value") {
    56  			return nil, []error{fmt.Errorf("value isn't computed")}
    57  		}
    58  
    59  		return nil, c.CheckSet([]string{"value"})
    60  	}
    61  
    62  	p.ConfigureFn = func(c *ResourceConfig) error {
    63  		return fmt.Errorf("Configure should not be called for provider")
    64  	}
    65  
    66  	w, e := c.Validate()
    67  	if len(w) > 0 {
    68  		t.Fatalf("bad: %#v", w)
    69  	}
    70  	if len(e) > 0 {
    71  		t.Fatalf("bad: %#v", e)
    72  	}
    73  }
    74  
    75  func TestContext2Validate_countNegative(t *testing.T) {
    76  	p := testProvider("aws")
    77  	m := testModule(t, "validate-count-negative")
    78  	c := testContext2(t, &ContextOpts{
    79  		Module: m,
    80  		Providers: map[string]ResourceProviderFactory{
    81  			"aws": testProviderFuncFixed(p),
    82  		},
    83  	})
    84  
    85  	w, e := c.Validate()
    86  	if len(w) > 0 {
    87  		t.Fatalf("bad: %#v", w)
    88  	}
    89  	if len(e) == 0 {
    90  		t.Fatalf("bad: %#v", e)
    91  	}
    92  }
    93  
    94  func TestContext2Validate_countVariable(t *testing.T) {
    95  	p := testProvider("aws")
    96  	m := testModule(t, "apply-count-variable")
    97  	c := testContext2(t, &ContextOpts{
    98  		Module: m,
    99  		Providers: map[string]ResourceProviderFactory{
   100  			"aws": testProviderFuncFixed(p),
   101  		},
   102  	})
   103  
   104  	w, e := c.Validate()
   105  	if len(w) > 0 {
   106  		t.Fatalf("bad: %#v", w)
   107  	}
   108  	if len(e) > 0 {
   109  		t.Fatalf("bad: %s", e)
   110  	}
   111  }
   112  
   113  func TestContext2Validate_countVariableNoDefault(t *testing.T) {
   114  	p := testProvider("aws")
   115  	m := testModule(t, "validate-count-variable")
   116  	c := testContext2(t, &ContextOpts{
   117  		Module: m,
   118  		Providers: map[string]ResourceProviderFactory{
   119  			"aws": testProviderFuncFixed(p),
   120  		},
   121  	})
   122  
   123  	w, e := c.Validate()
   124  	if len(w) > 0 {
   125  		t.Fatalf("bad: %#v", w)
   126  	}
   127  	if len(e) != 1 {
   128  		t.Fatalf("bad: %s", e)
   129  	}
   130  }
   131  
   132  /*
   133  TODO: What should we do here?
   134  func TestContext2Validate_cycle(t *testing.T) {
   135  	p := testProvider("aws")
   136  	m := testModule(t, "validate-cycle")
   137  	c := testContext2(t, &ContextOpts{
   138  		Module: m,
   139  		Providers: map[string]ResourceProviderFactory{
   140  			"aws": testProviderFuncFixed(p),
   141  		},
   142  	})
   143  
   144  	w, e := c.Validate()
   145  	if len(w) > 0 {
   146  		t.Fatalf("expected no warns, got: %#v", w)
   147  	}
   148  	if len(e) != 1 {
   149  		t.Fatalf("expected 1 err, got: %s", e)
   150  	}
   151  }
   152  */
   153  
   154  func TestContext2Validate_moduleBadOutput(t *testing.T) {
   155  	p := testProvider("aws")
   156  	m := testModule(t, "validate-bad-module-output")
   157  	c := testContext2(t, &ContextOpts{
   158  		Module: m,
   159  		Providers: map[string]ResourceProviderFactory{
   160  			"aws": testProviderFuncFixed(p),
   161  		},
   162  	})
   163  
   164  	w, e := c.Validate()
   165  	if len(w) > 0 {
   166  		t.Fatalf("bad: %#v", w)
   167  	}
   168  	if len(e) == 0 {
   169  		t.Fatalf("bad: %s", e)
   170  	}
   171  }
   172  
   173  func TestContext2Validate_moduleGood(t *testing.T) {
   174  	p := testProvider("aws")
   175  	m := testModule(t, "validate-good-module")
   176  	c := testContext2(t, &ContextOpts{
   177  		Module: m,
   178  		Providers: map[string]ResourceProviderFactory{
   179  			"aws": testProviderFuncFixed(p),
   180  		},
   181  	})
   182  
   183  	w, e := c.Validate()
   184  	if len(w) > 0 {
   185  		t.Fatalf("bad: %#v", w)
   186  	}
   187  	if len(e) > 0 {
   188  		t.Fatalf("bad: %#v", e)
   189  	}
   190  }
   191  
   192  func TestContext2Validate_moduleBadResource(t *testing.T) {
   193  	m := testModule(t, "validate-module-bad-rc")
   194  	p := testProvider("aws")
   195  	c := testContext2(t, &ContextOpts{
   196  		Module: m,
   197  		Providers: map[string]ResourceProviderFactory{
   198  			"aws": testProviderFuncFixed(p),
   199  		},
   200  	})
   201  
   202  	p.ValidateResourceReturnErrors = []error{fmt.Errorf("bad")}
   203  
   204  	w, e := c.Validate()
   205  	if len(w) > 0 {
   206  		t.Fatalf("bad: %#v", w)
   207  	}
   208  	if len(e) == 0 {
   209  		t.Fatalf("bad: %#v", e)
   210  	}
   211  }
   212  
   213  func TestContext2Validate_moduleDepsShouldNotCycle(t *testing.T) {
   214  	m := testModule(t, "validate-module-deps-cycle")
   215  	p := testProvider("aws")
   216  	ctx := testContext2(t, &ContextOpts{
   217  		Module: m,
   218  		Providers: map[string]ResourceProviderFactory{
   219  			"aws": testProviderFuncFixed(p),
   220  		},
   221  	})
   222  
   223  	w, e := ctx.Validate()
   224  
   225  	if len(w) > 0 {
   226  		t.Fatalf("expected no warnings, got: %s", w)
   227  	}
   228  	if len(e) > 0 {
   229  		t.Fatalf("expected no errors, got: %s", e)
   230  	}
   231  }
   232  
   233  func TestContext2Validate_moduleProviderInherit(t *testing.T) {
   234  	m := testModule(t, "validate-module-pc-inherit")
   235  	p := testProvider("aws")
   236  	c := testContext2(t, &ContextOpts{
   237  		Module: m,
   238  		Providers: map[string]ResourceProviderFactory{
   239  			"aws": testProviderFuncFixed(p),
   240  		},
   241  	})
   242  
   243  	p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
   244  		return nil, c.CheckSet([]string{"set"})
   245  	}
   246  
   247  	w, e := c.Validate()
   248  	if len(w) > 0 {
   249  		t.Fatalf("bad: %#v", w)
   250  	}
   251  	if len(e) > 0 {
   252  		t.Fatalf("bad: %s", e)
   253  	}
   254  }
   255  
   256  func TestContext2Validate_moduleProviderInheritOrphan(t *testing.T) {
   257  	m := testModule(t, "validate-module-pc-inherit-orphan")
   258  	p := testProvider("aws")
   259  	c := testContext2(t, &ContextOpts{
   260  		Module: m,
   261  		Providers: map[string]ResourceProviderFactory{
   262  			"aws": testProviderFuncFixed(p),
   263  		},
   264  		State: &State{
   265  			Modules: []*ModuleState{
   266  				&ModuleState{
   267  					Path: []string{"root", "child"},
   268  					Resources: map[string]*ResourceState{
   269  						"aws_instance.bar": &ResourceState{
   270  							Type: "aws_instance",
   271  							Primary: &InstanceState{
   272  								ID: "bar",
   273  							},
   274  						},
   275  					},
   276  				},
   277  			},
   278  		},
   279  	})
   280  
   281  	p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
   282  		v, ok := c.Get("set")
   283  		if !ok {
   284  			return nil, []error{fmt.Errorf("not set")}
   285  		}
   286  		if v != "bar" {
   287  			return nil, []error{fmt.Errorf("bad: %#v", v)}
   288  		}
   289  
   290  		return nil, nil
   291  	}
   292  
   293  	w, e := c.Validate()
   294  	if len(w) > 0 {
   295  		t.Fatalf("bad: %#v", w)
   296  	}
   297  	if len(e) > 0 {
   298  		t.Fatalf("bad: %s", e)
   299  	}
   300  }
   301  
   302  func TestContext2Validate_moduleProviderVar(t *testing.T) {
   303  	m := testModule(t, "validate-module-pc-vars")
   304  	p := testProvider("aws")
   305  	c := testContext2(t, &ContextOpts{
   306  		Module: m,
   307  		Providers: map[string]ResourceProviderFactory{
   308  			"aws": testProviderFuncFixed(p),
   309  		},
   310  		Variables: map[string]string{
   311  			"provider_var": "bar",
   312  		},
   313  	})
   314  
   315  	p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
   316  		return nil, c.CheckSet([]string{"foo"})
   317  	}
   318  
   319  	w, e := c.Validate()
   320  	if len(w) > 0 {
   321  		t.Fatalf("bad: %#v", w)
   322  	}
   323  	if len(e) > 0 {
   324  		t.Fatalf("bad: %s", e)
   325  	}
   326  }
   327  
   328  func TestContext2Validate_moduleProviderInheritUnused(t *testing.T) {
   329  	m := testModule(t, "validate-module-pc-inherit-unused")
   330  	p := testProvider("aws")
   331  	c := testContext2(t, &ContextOpts{
   332  		Module: m,
   333  		Providers: map[string]ResourceProviderFactory{
   334  			"aws": testProviderFuncFixed(p),
   335  		},
   336  	})
   337  
   338  	p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
   339  		return nil, c.CheckSet([]string{"foo"})
   340  	}
   341  
   342  	w, e := c.Validate()
   343  	if len(w) > 0 {
   344  		t.Fatalf("bad: %#v", w)
   345  	}
   346  	if len(e) > 0 {
   347  		t.Fatalf("bad: %s", e)
   348  	}
   349  }
   350  
   351  func TestContext2Validate_orphans(t *testing.T) {
   352  	p := testProvider("aws")
   353  	m := testModule(t, "validate-good")
   354  	state := &State{
   355  		Modules: []*ModuleState{
   356  			&ModuleState{
   357  				Path: rootModulePath,
   358  				Resources: map[string]*ResourceState{
   359  					"aws_instance.web": &ResourceState{
   360  						Type: "aws_instance",
   361  						Primary: &InstanceState{
   362  							ID: "bar",
   363  						},
   364  					},
   365  				},
   366  			},
   367  		},
   368  	}
   369  	c := testContext2(t, &ContextOpts{
   370  		Module: m,
   371  		Providers: map[string]ResourceProviderFactory{
   372  			"aws": testProviderFuncFixed(p),
   373  		},
   374  		State: state,
   375  	})
   376  
   377  	p.ValidateResourceFn = func(
   378  		t string, c *ResourceConfig) ([]string, []error) {
   379  		return nil, c.CheckSet([]string{"foo"})
   380  	}
   381  
   382  	w, e := c.Validate()
   383  	if len(w) > 0 {
   384  		t.Fatalf("bad: %#v", w)
   385  	}
   386  	if len(e) > 0 {
   387  		t.Fatalf("bad: %s", e)
   388  	}
   389  }
   390  
   391  func TestContext2Validate_providerConfig_bad(t *testing.T) {
   392  	m := testModule(t, "validate-bad-pc")
   393  	p := testProvider("aws")
   394  	c := testContext2(t, &ContextOpts{
   395  		Module: m,
   396  		Providers: map[string]ResourceProviderFactory{
   397  			"aws": testProviderFuncFixed(p),
   398  		},
   399  	})
   400  
   401  	p.ValidateReturnErrors = []error{fmt.Errorf("bad")}
   402  
   403  	w, e := c.Validate()
   404  	if len(w) > 0 {
   405  		t.Fatalf("bad: %#v", w)
   406  	}
   407  	if len(e) == 0 {
   408  		t.Fatalf("bad: %s", e)
   409  	}
   410  	if !strings.Contains(fmt.Sprintf("%s", e), "bad") {
   411  		t.Fatalf("bad: %s", e)
   412  	}
   413  }
   414  
   415  func TestContext2Validate_providerConfig_badEmpty(t *testing.T) {
   416  	m := testModule(t, "validate-bad-pc-empty")
   417  	p := testProvider("aws")
   418  	c := testContext2(t, &ContextOpts{
   419  		Module: m,
   420  		Providers: map[string]ResourceProviderFactory{
   421  			"aws": testProviderFuncFixed(p),
   422  		},
   423  	})
   424  
   425  	p.ValidateReturnErrors = []error{fmt.Errorf("bad")}
   426  
   427  	w, e := c.Validate()
   428  	if len(w) > 0 {
   429  		t.Fatalf("bad: %#v", w)
   430  	}
   431  	if len(e) == 0 {
   432  		t.Fatalf("bad: %#v", e)
   433  	}
   434  }
   435  
   436  func TestContext2Validate_providerConfig_good(t *testing.T) {
   437  	m := testModule(t, "validate-bad-pc")
   438  	p := testProvider("aws")
   439  	c := testContext2(t, &ContextOpts{
   440  		Module: m,
   441  		Providers: map[string]ResourceProviderFactory{
   442  			"aws": testProviderFuncFixed(p),
   443  		},
   444  	})
   445  
   446  	w, e := c.Validate()
   447  	if len(w) > 0 {
   448  		t.Fatalf("bad: %#v", w)
   449  	}
   450  	if len(e) > 0 {
   451  		t.Fatalf("bad: %#v", e)
   452  	}
   453  }
   454  
   455  func TestContext2Validate_provisionerConfig_bad(t *testing.T) {
   456  	m := testModule(t, "validate-bad-prov-conf")
   457  	p := testProvider("aws")
   458  	pr := testProvisioner()
   459  	c := testContext2(t, &ContextOpts{
   460  		Module: m,
   461  		Providers: map[string]ResourceProviderFactory{
   462  			"aws": testProviderFuncFixed(p),
   463  		},
   464  		Provisioners: map[string]ResourceProvisionerFactory{
   465  			"shell": testProvisionerFuncFixed(pr),
   466  		},
   467  	})
   468  
   469  	pr.ValidateReturnErrors = []error{fmt.Errorf("bad")}
   470  
   471  	w, e := c.Validate()
   472  	if len(w) > 0 {
   473  		t.Fatalf("bad: %#v", w)
   474  	}
   475  	if len(e) == 0 {
   476  		t.Fatalf("bad: %#v", e)
   477  	}
   478  }
   479  
   480  func TestContext2Validate_provisionerConfig_good(t *testing.T) {
   481  	m := testModule(t, "validate-bad-prov-conf")
   482  	p := testProvider("aws")
   483  	pr := testProvisioner()
   484  	pr.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
   485  		if c == nil {
   486  			t.Fatalf("missing resource config for provisioner")
   487  		}
   488  		return nil, c.CheckSet([]string{"command"})
   489  	}
   490  	c := testContext2(t, &ContextOpts{
   491  		Module: m,
   492  		Providers: map[string]ResourceProviderFactory{
   493  			"aws": testProviderFuncFixed(p),
   494  		},
   495  		Provisioners: map[string]ResourceProvisionerFactory{
   496  			"shell": testProvisionerFuncFixed(pr),
   497  		},
   498  	})
   499  
   500  	w, e := c.Validate()
   501  	if len(w) > 0 {
   502  		t.Fatalf("bad: %#v", w)
   503  	}
   504  	if len(e) > 0 {
   505  		t.Fatalf("bad: %#v", e)
   506  	}
   507  }
   508  
   509  func TestContext2Validate_requiredVar(t *testing.T) {
   510  	m := testModule(t, "validate-required-var")
   511  	p := testProvider("aws")
   512  	c := testContext2(t, &ContextOpts{
   513  		Module: m,
   514  		Providers: map[string]ResourceProviderFactory{
   515  			"aws": testProviderFuncFixed(p),
   516  		},
   517  	})
   518  
   519  	w, e := c.Validate()
   520  	if len(w) > 0 {
   521  		t.Fatalf("bad: %#v", w)
   522  	}
   523  	if len(e) == 0 {
   524  		t.Fatalf("bad: %s", e)
   525  	}
   526  }
   527  
   528  func TestContext2Validate_resourceConfig_bad(t *testing.T) {
   529  	m := testModule(t, "validate-bad-rc")
   530  	p := testProvider("aws")
   531  	c := testContext2(t, &ContextOpts{
   532  		Module: m,
   533  		Providers: map[string]ResourceProviderFactory{
   534  			"aws": testProviderFuncFixed(p),
   535  		},
   536  	})
   537  
   538  	p.ValidateResourceReturnErrors = []error{fmt.Errorf("bad")}
   539  
   540  	w, e := c.Validate()
   541  	if len(w) > 0 {
   542  		t.Fatalf("bad: %#v", w)
   543  	}
   544  	if len(e) == 0 {
   545  		t.Fatalf("bad: %s", e)
   546  	}
   547  }
   548  
   549  func TestContext2Validate_resourceConfig_good(t *testing.T) {
   550  	m := testModule(t, "validate-bad-rc")
   551  	p := testProvider("aws")
   552  	c := testContext2(t, &ContextOpts{
   553  		Module: m,
   554  		Providers: map[string]ResourceProviderFactory{
   555  			"aws": testProviderFuncFixed(p),
   556  		},
   557  	})
   558  
   559  	w, e := c.Validate()
   560  	if len(w) > 0 {
   561  		t.Fatalf("bad: %#v", w)
   562  	}
   563  	if len(e) > 0 {
   564  		t.Fatalf("bad: %#v", e)
   565  	}
   566  }
   567  
   568  func TestContext2Validate_resourceNameSymbol(t *testing.T) {
   569  	p := testProvider("aws")
   570  	m := testModule(t, "validate-resource-name-symbol")
   571  	c := testContext2(t, &ContextOpts{
   572  		Module: m,
   573  		Providers: map[string]ResourceProviderFactory{
   574  			"aws": testProviderFuncFixed(p),
   575  		},
   576  	})
   577  
   578  	w, e := c.Validate()
   579  	if len(w) > 0 {
   580  		t.Fatalf("bad: %#v", w)
   581  	}
   582  	if len(e) == 0 {
   583  		t.Fatalf("bad: %s", e)
   584  	}
   585  }
   586  
   587  func TestContext2Validate_selfRef(t *testing.T) {
   588  	p := testProvider("aws")
   589  	m := testModule(t, "validate-self-ref")
   590  	c := testContext2(t, &ContextOpts{
   591  		Module: m,
   592  		Providers: map[string]ResourceProviderFactory{
   593  			"aws": testProviderFuncFixed(p),
   594  		},
   595  	})
   596  
   597  	w, e := c.Validate()
   598  	if len(w) > 0 {
   599  		t.Fatalf("bad: %#v", w)
   600  	}
   601  	if len(e) == 0 {
   602  		t.Fatalf("bad: %s", e)
   603  	}
   604  }
   605  
   606  func TestContext2Validate_selfRefMulti(t *testing.T) {
   607  	p := testProvider("aws")
   608  	m := testModule(t, "validate-self-ref-multi")
   609  	c := testContext2(t, &ContextOpts{
   610  		Module: m,
   611  		Providers: map[string]ResourceProviderFactory{
   612  			"aws": testProviderFuncFixed(p),
   613  		},
   614  	})
   615  
   616  	w, e := c.Validate()
   617  	if len(w) > 0 {
   618  		t.Fatalf("bad: %#v", w)
   619  	}
   620  	if len(e) == 0 {
   621  		t.Fatalf("bad: %#v", e)
   622  	}
   623  }
   624  
   625  func TestContext2Validate_selfRefMultiAll(t *testing.T) {
   626  	p := testProvider("aws")
   627  	m := testModule(t, "validate-self-ref-multi-all")
   628  	c := testContext2(t, &ContextOpts{
   629  		Module: m,
   630  		Providers: map[string]ResourceProviderFactory{
   631  			"aws": testProviderFuncFixed(p),
   632  		},
   633  	})
   634  
   635  	w, e := c.Validate()
   636  	if len(w) > 0 {
   637  		t.Fatalf("bad: %#v", w)
   638  	}
   639  	if len(e) == 0 {
   640  		t.Fatalf("bad: %#v", e)
   641  	}
   642  }
   643  
   644  func TestContext2Validate_tainted(t *testing.T) {
   645  	p := testProvider("aws")
   646  	m := testModule(t, "validate-good")
   647  	state := &State{
   648  		Modules: []*ModuleState{
   649  			&ModuleState{
   650  				Path: rootModulePath,
   651  				Resources: map[string]*ResourceState{
   652  					"aws_instance.foo": &ResourceState{
   653  						Type: "aws_instance",
   654  						Primary: &InstanceState{
   655  							ID:      "bar",
   656  							Tainted: true,
   657  						},
   658  					},
   659  				},
   660  			},
   661  		},
   662  	}
   663  	c := testContext2(t, &ContextOpts{
   664  		Module: m,
   665  		Providers: map[string]ResourceProviderFactory{
   666  			"aws": testProviderFuncFixed(p),
   667  		},
   668  		State: state,
   669  	})
   670  
   671  	p.ValidateResourceFn = func(
   672  		t string, c *ResourceConfig) ([]string, []error) {
   673  		return nil, c.CheckSet([]string{"foo"})
   674  	}
   675  
   676  	w, e := c.Validate()
   677  	if len(w) > 0 {
   678  		t.Fatalf("bad: %#v", w)
   679  	}
   680  	if len(e) > 0 {
   681  		t.Fatalf("bad: %#v", e)
   682  	}
   683  }
   684  
   685  func TestContext2Validate_targetedDestroy(t *testing.T) {
   686  	m := testModule(t, "validate-targeted")
   687  	p := testProvider("aws")
   688  	pr := testProvisioner()
   689  	p.ApplyFn = testApplyFn
   690  	p.DiffFn = testDiffFn
   691  	ctx := testContext2(t, &ContextOpts{
   692  		Module: m,
   693  		Providers: map[string]ResourceProviderFactory{
   694  			"aws": testProviderFuncFixed(p),
   695  		},
   696  		Provisioners: map[string]ResourceProvisionerFactory{
   697  			"shell": testProvisionerFuncFixed(pr),
   698  		},
   699  		State: &State{
   700  			Modules: []*ModuleState{
   701  				&ModuleState{
   702  					Path: rootModulePath,
   703  					Resources: map[string]*ResourceState{
   704  						"aws_instance.foo": resourceState("aws_instance", "i-bcd345"),
   705  						"aws_instance.bar": resourceState("aws_instance", "i-abc123"),
   706  					},
   707  				},
   708  			},
   709  		},
   710  		Targets: []string{"aws_instance.foo"},
   711  		Destroy: true,
   712  	})
   713  
   714  	w, e := ctx.Validate()
   715  	if len(w) > 0 {
   716  		warnStr := ""
   717  		for _, v := range w {
   718  			warnStr = warnStr + " " + v
   719  		}
   720  		t.Fatalf("bad: %s", warnStr)
   721  	}
   722  	if len(e) > 0 {
   723  		t.Fatalf("bad: %s", e)
   724  	}
   725  }
   726  
   727  func TestContext2Validate_varRefFilled(t *testing.T) {
   728  	m := testModule(t, "validate-variable-ref")
   729  	p := testProvider("aws")
   730  	c := testContext2(t, &ContextOpts{
   731  		Module: m,
   732  		Providers: map[string]ResourceProviderFactory{
   733  			"aws": testProviderFuncFixed(p),
   734  		},
   735  		Variables: map[string]string{
   736  			"foo": "bar",
   737  		},
   738  	})
   739  
   740  	var value interface{}
   741  	p.ValidateResourceFn = func(t string, c *ResourceConfig) ([]string, []error) {
   742  		value, _ = c.Get("foo")
   743  		return nil, nil
   744  	}
   745  
   746  	c.Validate()
   747  	if value != "bar" {
   748  		t.Fatalf("bad: %#v", value)
   749  	}
   750  }
   751  
   752  // Module variables weren't being interpolated during Validate phase.
   753  // related to https://github.com/hashicorp/terraform/issues/5322
   754  func TestContext2Validate_interpolateVar(t *testing.T) {
   755  	input := new(MockUIInput)
   756  
   757  	m := testModule(t, "input-interpolate-var")
   758  	p := testProvider("null")
   759  	p.ApplyFn = testApplyFn
   760  	p.DiffFn = testDiffFn
   761  
   762  	ctx := testContext2(t, &ContextOpts{
   763  		Module: m,
   764  		Providers: map[string]ResourceProviderFactory{
   765  			"template": testProviderFuncFixed(p),
   766  		},
   767  		UIInput: input,
   768  	})
   769  
   770  	w, e := ctx.Validate()
   771  	if w != nil {
   772  		t.Log("warnings:", w)
   773  	}
   774  	if e != nil {
   775  		t.Fatal("err:", e)
   776  	}
   777  }
   778  
   779  // When module vars reference something that is actually computed, this
   780  // shouldn't cause validation to fail.
   781  func TestContext2Validate_interpolateComputedModuleVarDef(t *testing.T) {
   782  	input := new(MockUIInput)
   783  
   784  	m := testModule(t, "validate-computed-module-var-ref")
   785  	p := testProvider("aws")
   786  	p.ApplyFn = testApplyFn
   787  	p.DiffFn = testDiffFn
   788  
   789  	ctx := testContext2(t, &ContextOpts{
   790  		Module: m,
   791  		Providers: map[string]ResourceProviderFactory{
   792  			"aws": testProviderFuncFixed(p),
   793  		},
   794  		UIInput: input,
   795  	})
   796  
   797  	w, e := ctx.Validate()
   798  	if w != nil {
   799  		t.Log("warnings:", w)
   800  	}
   801  	if e != nil {
   802  		t.Fatal("err:", e)
   803  	}
   804  }