github.com/ricardclau/terraform@v0.6.17-0.20160519222547-283e3ae6b5a9/plugin/resource_provider_test.go (about)

     1  package plugin
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/go-plugin"
     9  	"github.com/hashicorp/terraform/terraform"
    10  )
    11  
    12  func TestResourceProvider_impl(t *testing.T) {
    13  	var _ plugin.Plugin = new(ResourceProviderPlugin)
    14  	var _ terraform.ResourceProvider = new(ResourceProvider)
    15  }
    16  
    17  func TestResourceProvider_input(t *testing.T) {
    18  	// Create a mock provider
    19  	p := new(terraform.MockResourceProvider)
    20  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
    21  		ProviderFunc: testProviderFixed(p),
    22  	}))
    23  	defer client.Close()
    24  
    25  	// Request the provider
    26  	raw, err := client.Dispense(ProviderPluginName)
    27  	if err != nil {
    28  		t.Fatalf("err: %s", err)
    29  	}
    30  	provider := raw.(terraform.ResourceProvider)
    31  
    32  	input := new(terraform.MockUIInput)
    33  
    34  	expected := &terraform.ResourceConfig{
    35  		Raw: map[string]interface{}{"bar": "baz"},
    36  	}
    37  	p.InputReturnConfig = expected
    38  
    39  	// Input
    40  	config := &terraform.ResourceConfig{
    41  		Raw: map[string]interface{}{"foo": "bar"},
    42  	}
    43  	actual, err := provider.Input(input, config)
    44  	if !p.InputCalled {
    45  		t.Fatal("input should be called")
    46  	}
    47  	if !reflect.DeepEqual(p.InputConfig, config) {
    48  		t.Fatalf("bad: %#v", p.InputConfig)
    49  	}
    50  	if err != nil {
    51  		t.Fatalf("bad: %#v", err)
    52  	}
    53  
    54  	if !reflect.DeepEqual(actual, expected) {
    55  		t.Fatalf("bad: %#v", actual)
    56  	}
    57  }
    58  
    59  func TestResourceProvider_configure(t *testing.T) {
    60  	// Create a mock provider
    61  	p := new(terraform.MockResourceProvider)
    62  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
    63  		ProviderFunc: testProviderFixed(p),
    64  	}))
    65  	defer client.Close()
    66  
    67  	// Request the provider
    68  	raw, err := client.Dispense(ProviderPluginName)
    69  	if err != nil {
    70  		t.Fatalf("err: %s", err)
    71  	}
    72  	provider := raw.(terraform.ResourceProvider)
    73  
    74  	// Configure
    75  	config := &terraform.ResourceConfig{
    76  		Raw: map[string]interface{}{"foo": "bar"},
    77  	}
    78  	e := provider.Configure(config)
    79  	if !p.ConfigureCalled {
    80  		t.Fatal("configure should be called")
    81  	}
    82  	if !reflect.DeepEqual(p.ConfigureConfig, config) {
    83  		t.Fatalf("bad: %#v", p.ConfigureConfig)
    84  	}
    85  	if e != nil {
    86  		t.Fatalf("bad: %#v", e)
    87  	}
    88  }
    89  
    90  func TestResourceProvider_configure_errors(t *testing.T) {
    91  	p := new(terraform.MockResourceProvider)
    92  	p.ConfigureReturnError = errors.New("foo")
    93  
    94  	// Create a mock provider
    95  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
    96  		ProviderFunc: testProviderFixed(p),
    97  	}))
    98  	defer client.Close()
    99  
   100  	// Request the provider
   101  	raw, err := client.Dispense(ProviderPluginName)
   102  	if err != nil {
   103  		t.Fatalf("err: %s", err)
   104  	}
   105  	provider := raw.(terraform.ResourceProvider)
   106  
   107  	// Configure
   108  	config := &terraform.ResourceConfig{
   109  		Raw: map[string]interface{}{"foo": "bar"},
   110  	}
   111  	e := provider.Configure(config)
   112  	if !p.ConfigureCalled {
   113  		t.Fatal("configure should be called")
   114  	}
   115  	if !reflect.DeepEqual(p.ConfigureConfig, config) {
   116  		t.Fatalf("bad: %#v", p.ConfigureConfig)
   117  	}
   118  	if e == nil {
   119  		t.Fatal("should have error")
   120  	}
   121  	if e.Error() != "foo" {
   122  		t.Fatalf("bad: %s", e)
   123  	}
   124  }
   125  
   126  func TestResourceProvider_configure_warnings(t *testing.T) {
   127  	p := new(terraform.MockResourceProvider)
   128  
   129  	// Create a mock provider
   130  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   131  		ProviderFunc: testProviderFixed(p),
   132  	}))
   133  	defer client.Close()
   134  
   135  	// Request the provider
   136  	raw, err := client.Dispense(ProviderPluginName)
   137  	if err != nil {
   138  		t.Fatalf("err: %s", err)
   139  	}
   140  	provider := raw.(terraform.ResourceProvider)
   141  
   142  	// Configure
   143  	config := &terraform.ResourceConfig{
   144  		Raw: map[string]interface{}{"foo": "bar"},
   145  	}
   146  	e := provider.Configure(config)
   147  	if !p.ConfigureCalled {
   148  		t.Fatal("configure should be called")
   149  	}
   150  	if !reflect.DeepEqual(p.ConfigureConfig, config) {
   151  		t.Fatalf("bad: %#v", p.ConfigureConfig)
   152  	}
   153  	if e != nil {
   154  		t.Fatalf("bad: %#v", e)
   155  	}
   156  }
   157  
   158  func TestResourceProvider_apply(t *testing.T) {
   159  	p := new(terraform.MockResourceProvider)
   160  
   161  	// Create a mock provider
   162  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   163  		ProviderFunc: testProviderFixed(p),
   164  	}))
   165  	defer client.Close()
   166  
   167  	// Request the provider
   168  	raw, err := client.Dispense(ProviderPluginName)
   169  	if err != nil {
   170  		t.Fatalf("err: %s", err)
   171  	}
   172  	provider := raw.(terraform.ResourceProvider)
   173  
   174  	p.ApplyReturn = &terraform.InstanceState{
   175  		ID: "bob",
   176  	}
   177  
   178  	// Apply
   179  	info := &terraform.InstanceInfo{}
   180  	state := &terraform.InstanceState{}
   181  	diff := &terraform.InstanceDiff{}
   182  	newState, err := provider.Apply(info, state, diff)
   183  	if !p.ApplyCalled {
   184  		t.Fatal("apply should be called")
   185  	}
   186  	if !reflect.DeepEqual(p.ApplyDiff, diff) {
   187  		t.Fatalf("bad: %#v", p.ApplyDiff)
   188  	}
   189  	if err != nil {
   190  		t.Fatalf("bad: %#v", err)
   191  	}
   192  	if !reflect.DeepEqual(p.ApplyReturn, newState) {
   193  		t.Fatalf("bad: %#v", newState)
   194  	}
   195  }
   196  
   197  func TestResourceProvider_diff(t *testing.T) {
   198  	p := new(terraform.MockResourceProvider)
   199  
   200  	// Create a mock provider
   201  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   202  		ProviderFunc: testProviderFixed(p),
   203  	}))
   204  	defer client.Close()
   205  
   206  	// Request the provider
   207  	raw, err := client.Dispense(ProviderPluginName)
   208  	if err != nil {
   209  		t.Fatalf("err: %s", err)
   210  	}
   211  	provider := raw.(terraform.ResourceProvider)
   212  
   213  	p.DiffReturn = &terraform.InstanceDiff{
   214  		Attributes: map[string]*terraform.ResourceAttrDiff{
   215  			"foo": &terraform.ResourceAttrDiff{
   216  				Old: "",
   217  				New: "bar",
   218  			},
   219  		},
   220  	}
   221  
   222  	// Diff
   223  	info := &terraform.InstanceInfo{}
   224  	state := &terraform.InstanceState{}
   225  	config := &terraform.ResourceConfig{
   226  		Raw: map[string]interface{}{"foo": "bar"},
   227  	}
   228  	diff, err := provider.Diff(info, state, config)
   229  	if !p.DiffCalled {
   230  		t.Fatal("diff should be called")
   231  	}
   232  	if !reflect.DeepEqual(p.DiffDesired, config) {
   233  		t.Fatalf("bad: %#v", p.DiffDesired)
   234  	}
   235  	if err != nil {
   236  		t.Fatalf("bad: %#v", err)
   237  	}
   238  	if !reflect.DeepEqual(p.DiffReturn, diff) {
   239  		t.Fatalf("bad: %#v", diff)
   240  	}
   241  }
   242  
   243  func TestResourceProvider_diff_error(t *testing.T) {
   244  	p := new(terraform.MockResourceProvider)
   245  
   246  	// Create a mock provider
   247  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   248  		ProviderFunc: testProviderFixed(p),
   249  	}))
   250  	defer client.Close()
   251  
   252  	// Request the provider
   253  	raw, err := client.Dispense(ProviderPluginName)
   254  	if err != nil {
   255  		t.Fatalf("err: %s", err)
   256  	}
   257  	provider := raw.(terraform.ResourceProvider)
   258  
   259  	p.DiffReturnError = errors.New("foo")
   260  
   261  	// Diff
   262  	info := &terraform.InstanceInfo{}
   263  	state := &terraform.InstanceState{}
   264  	config := &terraform.ResourceConfig{
   265  		Raw: map[string]interface{}{"foo": "bar"},
   266  	}
   267  	diff, err := provider.Diff(info, state, config)
   268  	if !p.DiffCalled {
   269  		t.Fatal("diff should be called")
   270  	}
   271  	if !reflect.DeepEqual(p.DiffDesired, config) {
   272  		t.Fatalf("bad: %#v", p.DiffDesired)
   273  	}
   274  	if err == nil {
   275  		t.Fatal("should have error")
   276  	}
   277  	if diff != nil {
   278  		t.Fatal("should not have diff")
   279  	}
   280  }
   281  
   282  func TestResourceProvider_refresh(t *testing.T) {
   283  	p := new(terraform.MockResourceProvider)
   284  
   285  	// Create a mock provider
   286  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   287  		ProviderFunc: testProviderFixed(p),
   288  	}))
   289  	defer client.Close()
   290  
   291  	// Request the provider
   292  	raw, err := client.Dispense(ProviderPluginName)
   293  	if err != nil {
   294  		t.Fatalf("err: %s", err)
   295  	}
   296  	provider := raw.(terraform.ResourceProvider)
   297  
   298  	p.RefreshReturn = &terraform.InstanceState{
   299  		ID: "bob",
   300  	}
   301  
   302  	// Refresh
   303  	info := &terraform.InstanceInfo{}
   304  	state := &terraform.InstanceState{}
   305  	newState, err := provider.Refresh(info, state)
   306  	if !p.RefreshCalled {
   307  		t.Fatal("refresh should be called")
   308  	}
   309  	if !reflect.DeepEqual(p.RefreshState, state) {
   310  		t.Fatalf("bad: %#v", p.RefreshState)
   311  	}
   312  	if err != nil {
   313  		t.Fatalf("bad: %#v", err)
   314  	}
   315  	if !reflect.DeepEqual(p.RefreshReturn, newState) {
   316  		t.Fatalf("bad: %#v", newState)
   317  	}
   318  }
   319  
   320  func TestResourceProvider_importState(t *testing.T) {
   321  	p := new(terraform.MockResourceProvider)
   322  
   323  	// Create a mock provider
   324  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   325  		ProviderFunc: testProviderFixed(p),
   326  	}))
   327  	defer client.Close()
   328  
   329  	// Request the provider
   330  	raw, err := client.Dispense(ProviderPluginName)
   331  	if err != nil {
   332  		t.Fatalf("err: %s", err)
   333  	}
   334  	provider := raw.(terraform.ResourceProvider)
   335  
   336  	p.ImportStateReturn = []*terraform.InstanceState{
   337  		&terraform.InstanceState{
   338  			ID: "bob",
   339  		},
   340  	}
   341  
   342  	// ImportState
   343  	info := &terraform.InstanceInfo{}
   344  	states, err := provider.ImportState(info, "foo")
   345  	if !p.ImportStateCalled {
   346  		t.Fatal("ImportState should be called")
   347  	}
   348  	if !reflect.DeepEqual(p.ImportStateInfo, info) {
   349  		t.Fatalf("bad: %#v", p.ImportStateInfo)
   350  	}
   351  	if err != nil {
   352  		t.Fatalf("bad: %#v", err)
   353  	}
   354  	if !reflect.DeepEqual(p.ImportStateReturn, states) {
   355  		t.Fatalf("bad: %#v", states)
   356  	}
   357  }
   358  
   359  func TestResourceProvider_resources(t *testing.T) {
   360  	p := new(terraform.MockResourceProvider)
   361  
   362  	// Create a mock provider
   363  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   364  		ProviderFunc: testProviderFixed(p),
   365  	}))
   366  	defer client.Close()
   367  
   368  	// Request the provider
   369  	raw, err := client.Dispense(ProviderPluginName)
   370  	if err != nil {
   371  		t.Fatalf("err: %s", err)
   372  	}
   373  	provider := raw.(terraform.ResourceProvider)
   374  
   375  	expected := []terraform.ResourceType{
   376  		terraform.ResourceType{Name: "foo"},
   377  		terraform.ResourceType{Name: "bar", Importable: true},
   378  	}
   379  
   380  	p.ResourcesReturn = expected
   381  
   382  	// Resources
   383  	result := provider.Resources()
   384  	if !p.ResourcesCalled {
   385  		t.Fatal("resources should be called")
   386  	}
   387  	if !reflect.DeepEqual(result, expected) {
   388  		t.Fatalf("bad: %#v", result)
   389  	}
   390  }
   391  
   392  func TestResourceProvider_readdataapply(t *testing.T) {
   393  	p := new(terraform.MockResourceProvider)
   394  
   395  	// Create a mock provider
   396  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   397  		ProviderFunc: testProviderFixed(p),
   398  	}))
   399  	defer client.Close()
   400  
   401  	// Request the provider
   402  	raw, err := client.Dispense(ProviderPluginName)
   403  	if err != nil {
   404  		t.Fatalf("err: %s", err)
   405  	}
   406  	provider := raw.(terraform.ResourceProvider)
   407  
   408  	p.ReadDataApplyReturn = &terraform.InstanceState{
   409  		ID: "bob",
   410  	}
   411  
   412  	// ReadDataApply
   413  	info := &terraform.InstanceInfo{}
   414  	diff := &terraform.InstanceDiff{}
   415  	newState, err := provider.ReadDataApply(info, diff)
   416  	if !p.ReadDataApplyCalled {
   417  		t.Fatal("ReadDataApply should be called")
   418  	}
   419  	if !reflect.DeepEqual(p.ReadDataApplyDiff, diff) {
   420  		t.Fatalf("bad: %#v", p.ReadDataApplyDiff)
   421  	}
   422  	if err != nil {
   423  		t.Fatalf("bad: %#v", err)
   424  	}
   425  	if !reflect.DeepEqual(p.ReadDataApplyReturn, newState) {
   426  		t.Fatalf("bad: %#v", newState)
   427  	}
   428  }
   429  
   430  func TestResourceProvider_datasources(t *testing.T) {
   431  	p := new(terraform.MockResourceProvider)
   432  
   433  	// Create a mock provider
   434  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   435  		ProviderFunc: testProviderFixed(p),
   436  	}))
   437  	defer client.Close()
   438  
   439  	// Request the provider
   440  	raw, err := client.Dispense(ProviderPluginName)
   441  	if err != nil {
   442  		t.Fatalf("err: %s", err)
   443  	}
   444  	provider := raw.(terraform.ResourceProvider)
   445  
   446  	expected := []terraform.DataSource{
   447  		{"foo"},
   448  		{"bar"},
   449  	}
   450  
   451  	p.DataSourcesReturn = expected
   452  
   453  	// DataSources
   454  	result := provider.DataSources()
   455  	if !p.DataSourcesCalled {
   456  		t.Fatal("DataSources should be called")
   457  	}
   458  	if !reflect.DeepEqual(result, expected) {
   459  		t.Fatalf("bad: %#v", result)
   460  	}
   461  }
   462  
   463  func TestResourceProvider_validate(t *testing.T) {
   464  	p := new(terraform.MockResourceProvider)
   465  
   466  	// Create a mock provider
   467  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   468  		ProviderFunc: testProviderFixed(p),
   469  	}))
   470  	defer client.Close()
   471  
   472  	// Request the provider
   473  	raw, err := client.Dispense(ProviderPluginName)
   474  	if err != nil {
   475  		t.Fatalf("err: %s", err)
   476  	}
   477  	provider := raw.(terraform.ResourceProvider)
   478  
   479  	// Configure
   480  	config := &terraform.ResourceConfig{
   481  		Raw: map[string]interface{}{"foo": "bar"},
   482  	}
   483  	w, e := provider.Validate(config)
   484  	if !p.ValidateCalled {
   485  		t.Fatal("configure should be called")
   486  	}
   487  	if !reflect.DeepEqual(p.ValidateConfig, config) {
   488  		t.Fatalf("bad: %#v", p.ValidateConfig)
   489  	}
   490  	if w != nil {
   491  		t.Fatalf("bad: %#v", w)
   492  	}
   493  	if e != nil {
   494  		t.Fatalf("bad: %#v", e)
   495  	}
   496  }
   497  
   498  func TestResourceProvider_validate_errors(t *testing.T) {
   499  	p := new(terraform.MockResourceProvider)
   500  
   501  	// Create a mock provider
   502  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   503  		ProviderFunc: testProviderFixed(p),
   504  	}))
   505  	defer client.Close()
   506  
   507  	// Request the provider
   508  	raw, err := client.Dispense(ProviderPluginName)
   509  	if err != nil {
   510  		t.Fatalf("err: %s", err)
   511  	}
   512  	provider := raw.(terraform.ResourceProvider)
   513  
   514  	p.ValidateReturnErrors = []error{errors.New("foo")}
   515  
   516  	// Configure
   517  	config := &terraform.ResourceConfig{
   518  		Raw: map[string]interface{}{"foo": "bar"},
   519  	}
   520  	w, e := provider.Validate(config)
   521  	if !p.ValidateCalled {
   522  		t.Fatal("configure should be called")
   523  	}
   524  	if !reflect.DeepEqual(p.ValidateConfig, config) {
   525  		t.Fatalf("bad: %#v", p.ValidateConfig)
   526  	}
   527  	if w != nil {
   528  		t.Fatalf("bad: %#v", w)
   529  	}
   530  
   531  	if len(e) != 1 {
   532  		t.Fatalf("bad: %#v", e)
   533  	}
   534  	if e[0].Error() != "foo" {
   535  		t.Fatalf("bad: %#v", e)
   536  	}
   537  }
   538  
   539  func TestResourceProvider_validate_warns(t *testing.T) {
   540  	p := new(terraform.MockResourceProvider)
   541  
   542  	// Create a mock provider
   543  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   544  		ProviderFunc: testProviderFixed(p),
   545  	}))
   546  	defer client.Close()
   547  
   548  	// Request the provider
   549  	raw, err := client.Dispense(ProviderPluginName)
   550  	if err != nil {
   551  		t.Fatalf("err: %s", err)
   552  	}
   553  	provider := raw.(terraform.ResourceProvider)
   554  
   555  	p.ValidateReturnWarns = []string{"foo"}
   556  
   557  	// Configure
   558  	config := &terraform.ResourceConfig{
   559  		Raw: map[string]interface{}{"foo": "bar"},
   560  	}
   561  	w, e := provider.Validate(config)
   562  	if !p.ValidateCalled {
   563  		t.Fatal("configure should be called")
   564  	}
   565  	if !reflect.DeepEqual(p.ValidateConfig, config) {
   566  		t.Fatalf("bad: %#v", p.ValidateConfig)
   567  	}
   568  	if e != nil {
   569  		t.Fatalf("bad: %#v", e)
   570  	}
   571  
   572  	expected := []string{"foo"}
   573  	if !reflect.DeepEqual(w, expected) {
   574  		t.Fatalf("bad: %#v", w)
   575  	}
   576  }
   577  
   578  func TestResourceProvider_validateResource(t *testing.T) {
   579  	p := new(terraform.MockResourceProvider)
   580  
   581  	// Create a mock provider
   582  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   583  		ProviderFunc: testProviderFixed(p),
   584  	}))
   585  	defer client.Close()
   586  
   587  	// Request the provider
   588  	raw, err := client.Dispense(ProviderPluginName)
   589  	if err != nil {
   590  		t.Fatalf("err: %s", err)
   591  	}
   592  	provider := raw.(terraform.ResourceProvider)
   593  
   594  	// Configure
   595  	config := &terraform.ResourceConfig{
   596  		Raw: map[string]interface{}{"foo": "bar"},
   597  	}
   598  	w, e := provider.ValidateResource("foo", config)
   599  	if !p.ValidateResourceCalled {
   600  		t.Fatal("configure should be called")
   601  	}
   602  	if p.ValidateResourceType != "foo" {
   603  		t.Fatalf("bad: %#v", p.ValidateResourceType)
   604  	}
   605  	if !reflect.DeepEqual(p.ValidateResourceConfig, config) {
   606  		t.Fatalf("bad: %#v", p.ValidateResourceConfig)
   607  	}
   608  	if w != nil {
   609  		t.Fatalf("bad: %#v", w)
   610  	}
   611  	if e != nil {
   612  		t.Fatalf("bad: %#v", e)
   613  	}
   614  }
   615  
   616  func TestResourceProvider_validateResource_errors(t *testing.T) {
   617  	p := new(terraform.MockResourceProvider)
   618  
   619  	// Create a mock provider
   620  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   621  		ProviderFunc: testProviderFixed(p),
   622  	}))
   623  	defer client.Close()
   624  
   625  	// Request the provider
   626  	raw, err := client.Dispense(ProviderPluginName)
   627  	if err != nil {
   628  		t.Fatalf("err: %s", err)
   629  	}
   630  	provider := raw.(terraform.ResourceProvider)
   631  
   632  	p.ValidateResourceReturnErrors = []error{errors.New("foo")}
   633  
   634  	// Configure
   635  	config := &terraform.ResourceConfig{
   636  		Raw: map[string]interface{}{"foo": "bar"},
   637  	}
   638  	w, e := provider.ValidateResource("foo", config)
   639  	if !p.ValidateResourceCalled {
   640  		t.Fatal("configure should be called")
   641  	}
   642  	if p.ValidateResourceType != "foo" {
   643  		t.Fatalf("bad: %#v", p.ValidateResourceType)
   644  	}
   645  	if !reflect.DeepEqual(p.ValidateResourceConfig, config) {
   646  		t.Fatalf("bad: %#v", p.ValidateResourceConfig)
   647  	}
   648  	if w != nil {
   649  		t.Fatalf("bad: %#v", w)
   650  	}
   651  
   652  	if len(e) != 1 {
   653  		t.Fatalf("bad: %#v", e)
   654  	}
   655  	if e[0].Error() != "foo" {
   656  		t.Fatalf("bad: %#v", e)
   657  	}
   658  }
   659  
   660  func TestResourceProvider_validateResource_warns(t *testing.T) {
   661  	p := new(terraform.MockResourceProvider)
   662  
   663  	// Create a mock provider
   664  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   665  		ProviderFunc: testProviderFixed(p),
   666  	}))
   667  	defer client.Close()
   668  
   669  	// Request the provider
   670  	raw, err := client.Dispense(ProviderPluginName)
   671  	if err != nil {
   672  		t.Fatalf("err: %s", err)
   673  	}
   674  	provider := raw.(terraform.ResourceProvider)
   675  
   676  	p.ValidateResourceReturnWarns = []string{"foo"}
   677  
   678  	// Configure
   679  	config := &terraform.ResourceConfig{
   680  		Raw: map[string]interface{}{"foo": "bar"},
   681  	}
   682  	w, e := provider.ValidateResource("foo", config)
   683  	if !p.ValidateResourceCalled {
   684  		t.Fatal("configure should be called")
   685  	}
   686  	if p.ValidateResourceType != "foo" {
   687  		t.Fatalf("bad: %#v", p.ValidateResourceType)
   688  	}
   689  	if !reflect.DeepEqual(p.ValidateResourceConfig, config) {
   690  		t.Fatalf("bad: %#v", p.ValidateResourceConfig)
   691  	}
   692  	if e != nil {
   693  		t.Fatalf("bad: %#v", e)
   694  	}
   695  
   696  	expected := []string{"foo"}
   697  	if !reflect.DeepEqual(w, expected) {
   698  		t.Fatalf("bad: %#v", w)
   699  	}
   700  }
   701  
   702  func TestResourceProvider_validateDataSource(t *testing.T) {
   703  	p := new(terraform.MockResourceProvider)
   704  
   705  	// Create a mock provider
   706  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   707  		ProviderFunc: testProviderFixed(p),
   708  	}))
   709  	defer client.Close()
   710  
   711  	// Request the provider
   712  	raw, err := client.Dispense(ProviderPluginName)
   713  	if err != nil {
   714  		t.Fatalf("err: %s", err)
   715  	}
   716  	provider := raw.(terraform.ResourceProvider)
   717  
   718  	// Configure
   719  	config := &terraform.ResourceConfig{
   720  		Raw: map[string]interface{}{"foo": "bar"},
   721  	}
   722  	w, e := provider.ValidateDataSource("foo", config)
   723  	if !p.ValidateDataSourceCalled {
   724  		t.Fatal("configure should be called")
   725  	}
   726  	if p.ValidateDataSourceType != "foo" {
   727  		t.Fatalf("bad: %#v", p.ValidateDataSourceType)
   728  	}
   729  	if !reflect.DeepEqual(p.ValidateDataSourceConfig, config) {
   730  		t.Fatalf("bad: %#v", p.ValidateDataSourceConfig)
   731  	}
   732  	if w != nil {
   733  		t.Fatalf("bad: %#v", w)
   734  	}
   735  	if e != nil {
   736  		t.Fatalf("bad: %#v", e)
   737  	}
   738  }
   739  
   740  func TestResourceProvider_close(t *testing.T) {
   741  	p := new(terraform.MockResourceProvider)
   742  
   743  	// Create a mock provider
   744  	client, _ := plugin.TestPluginRPCConn(t, pluginMap(&ServeOpts{
   745  		ProviderFunc: testProviderFixed(p),
   746  	}))
   747  	defer client.Close()
   748  
   749  	// Request the provider
   750  	raw, err := client.Dispense(ProviderPluginName)
   751  	if err != nil {
   752  		t.Fatalf("err: %s", err)
   753  	}
   754  	provider := raw.(terraform.ResourceProvider)
   755  
   756  	var iface interface{} = provider
   757  	pCloser, ok := iface.(terraform.ResourceProviderCloser)
   758  	if !ok {
   759  		t.Fatal("should be a ResourceProviderCloser")
   760  	}
   761  
   762  	if err := pCloser.Close(); err != nil {
   763  		t.Fatalf("failed to close provider: %s", err)
   764  	}
   765  
   766  	// The connection should be closed now, so if we to make a
   767  	// new call we should get an error.
   768  	err = provider.Configure(&terraform.ResourceConfig{})
   769  	if err == nil {
   770  		t.Fatal("should have error")
   771  	}
   772  }