github.com/ezbercih/terraform@v0.1.1-0.20140729011846-3c33865e0839/rpc/resource_provider_test.go (about)

     1  package rpc
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/terraform/terraform"
     9  )
    10  
    11  func TestResourceProvider_impl(t *testing.T) {
    12  	var _ terraform.ResourceProvider = new(ResourceProvider)
    13  }
    14  
    15  func TestResourceProvider_configure(t *testing.T) {
    16  	p := new(terraform.MockResourceProvider)
    17  	client, server := testClientServer(t)
    18  	name, err := Register(server, p)
    19  	if err != nil {
    20  		t.Fatalf("err: %s", err)
    21  	}
    22  	provider := &ResourceProvider{Client: client, Name: name}
    23  
    24  	// Configure
    25  	config := &terraform.ResourceConfig{
    26  		Raw: map[string]interface{}{"foo": "bar"},
    27  	}
    28  	e := provider.Configure(config)
    29  	if !p.ConfigureCalled {
    30  		t.Fatal("configure should be called")
    31  	}
    32  	if !reflect.DeepEqual(p.ConfigureConfig, config) {
    33  		t.Fatalf("bad: %#v", p.ConfigureConfig)
    34  	}
    35  	if e != nil {
    36  		t.Fatalf("bad: %#v", e)
    37  	}
    38  }
    39  
    40  func TestResourceProvider_configure_errors(t *testing.T) {
    41  	p := new(terraform.MockResourceProvider)
    42  	client, server := testClientServer(t)
    43  	name, err := Register(server, p)
    44  	if err != nil {
    45  		t.Fatalf("err: %s", err)
    46  	}
    47  	provider := &ResourceProvider{Client: client, Name: name}
    48  
    49  	p.ConfigureReturnError = errors.New("foo")
    50  
    51  	// Configure
    52  	config := &terraform.ResourceConfig{
    53  		Raw: map[string]interface{}{"foo": "bar"},
    54  	}
    55  	e := provider.Configure(config)
    56  	if !p.ConfigureCalled {
    57  		t.Fatal("configure should be called")
    58  	}
    59  	if !reflect.DeepEqual(p.ConfigureConfig, config) {
    60  		t.Fatalf("bad: %#v", p.ConfigureConfig)
    61  	}
    62  	if e == nil {
    63  		t.Fatal("should have error")
    64  	}
    65  	if e.Error() != "foo" {
    66  		t.Fatalf("bad: %s", e)
    67  	}
    68  }
    69  
    70  func TestResourceProvider_configure_warnings(t *testing.T) {
    71  	p := new(terraform.MockResourceProvider)
    72  	client, server := testClientServer(t)
    73  	name, err := Register(server, p)
    74  	if err != nil {
    75  		t.Fatalf("err: %s", err)
    76  	}
    77  	provider := &ResourceProvider{Client: client, Name: name}
    78  
    79  	// Configure
    80  	config := &terraform.ResourceConfig{
    81  		Raw: map[string]interface{}{"foo": "bar"},
    82  	}
    83  	e := provider.Configure(config)
    84  	if !p.ConfigureCalled {
    85  		t.Fatal("configure should be called")
    86  	}
    87  	if !reflect.DeepEqual(p.ConfigureConfig, config) {
    88  		t.Fatalf("bad: %#v", p.ConfigureConfig)
    89  	}
    90  	if e != nil {
    91  		t.Fatalf("bad: %#v", e)
    92  	}
    93  }
    94  
    95  func TestResourceProvider_apply(t *testing.T) {
    96  	p := new(terraform.MockResourceProvider)
    97  	client, server := testClientServer(t)
    98  	name, err := Register(server, p)
    99  	if err != nil {
   100  		t.Fatalf("err: %s", err)
   101  	}
   102  	provider := &ResourceProvider{Client: client, Name: name}
   103  
   104  	p.ApplyReturn = &terraform.ResourceState{
   105  		ID: "bob",
   106  	}
   107  
   108  	// Apply
   109  	state := &terraform.ResourceState{}
   110  	diff := &terraform.ResourceDiff{}
   111  	newState, err := provider.Apply(state, diff)
   112  	if !p.ApplyCalled {
   113  		t.Fatal("apply should be called")
   114  	}
   115  	if !reflect.DeepEqual(p.ApplyDiff, diff) {
   116  		t.Fatalf("bad: %#v", p.ApplyDiff)
   117  	}
   118  	if err != nil {
   119  		t.Fatalf("bad: %#v", err)
   120  	}
   121  	if !reflect.DeepEqual(p.ApplyReturn, newState) {
   122  		t.Fatalf("bad: %#v", newState)
   123  	}
   124  }
   125  
   126  func TestResourceProvider_diff(t *testing.T) {
   127  	p := new(terraform.MockResourceProvider)
   128  	client, server := testClientServer(t)
   129  	name, err := Register(server, p)
   130  	if err != nil {
   131  		t.Fatalf("err: %s", err)
   132  	}
   133  	provider := &ResourceProvider{Client: client, Name: name}
   134  
   135  	p.DiffReturn = &terraform.ResourceDiff{
   136  		Attributes: map[string]*terraform.ResourceAttrDiff{
   137  			"foo": &terraform.ResourceAttrDiff{
   138  				Old: "",
   139  				New: "bar",
   140  			},
   141  		},
   142  	}
   143  
   144  	// Diff
   145  	state := &terraform.ResourceState{}
   146  	config := &terraform.ResourceConfig{
   147  		Raw: map[string]interface{}{"foo": "bar"},
   148  	}
   149  	diff, err := provider.Diff(state, config)
   150  	if !p.DiffCalled {
   151  		t.Fatal("diff should be called")
   152  	}
   153  	if !reflect.DeepEqual(p.DiffDesired, config) {
   154  		t.Fatalf("bad: %#v", p.DiffDesired)
   155  	}
   156  	if err != nil {
   157  		t.Fatalf("bad: %#v", err)
   158  	}
   159  	if !reflect.DeepEqual(p.DiffReturn, diff) {
   160  		t.Fatalf("bad: %#v", diff)
   161  	}
   162  }
   163  
   164  func TestResourceProvider_diff_error(t *testing.T) {
   165  	p := new(terraform.MockResourceProvider)
   166  	client, server := testClientServer(t)
   167  	name, err := Register(server, p)
   168  	if err != nil {
   169  		t.Fatalf("err: %s", err)
   170  	}
   171  	provider := &ResourceProvider{Client: client, Name: name}
   172  
   173  	p.DiffReturnError = errors.New("foo")
   174  
   175  	// Diff
   176  	state := &terraform.ResourceState{}
   177  	config := &terraform.ResourceConfig{
   178  		Raw: map[string]interface{}{"foo": "bar"},
   179  	}
   180  	diff, err := provider.Diff(state, config)
   181  	if !p.DiffCalled {
   182  		t.Fatal("diff should be called")
   183  	}
   184  	if !reflect.DeepEqual(p.DiffDesired, config) {
   185  		t.Fatalf("bad: %#v", p.DiffDesired)
   186  	}
   187  	if err == nil {
   188  		t.Fatal("should have error")
   189  	}
   190  	if diff != nil {
   191  		t.Fatal("should not have diff")
   192  	}
   193  }
   194  
   195  func TestResourceProvider_refresh(t *testing.T) {
   196  	p := new(terraform.MockResourceProvider)
   197  	client, server := testClientServer(t)
   198  	name, err := Register(server, p)
   199  	if err != nil {
   200  		t.Fatalf("err: %s", err)
   201  	}
   202  	provider := &ResourceProvider{Client: client, Name: name}
   203  
   204  	p.RefreshReturn = &terraform.ResourceState{
   205  		ID: "bob",
   206  	}
   207  
   208  	// Refresh
   209  	state := &terraform.ResourceState{}
   210  	newState, err := provider.Refresh(state)
   211  	if !p.RefreshCalled {
   212  		t.Fatal("refresh should be called")
   213  	}
   214  	if !reflect.DeepEqual(p.RefreshState, state) {
   215  		t.Fatalf("bad: %#v", p.RefreshState)
   216  	}
   217  	if err != nil {
   218  		t.Fatalf("bad: %#v", err)
   219  	}
   220  	if !reflect.DeepEqual(p.RefreshReturn, newState) {
   221  		t.Fatalf("bad: %#v", newState)
   222  	}
   223  }
   224  
   225  func TestResourceProvider_resources(t *testing.T) {
   226  	p := new(terraform.MockResourceProvider)
   227  	client, server := testClientServer(t)
   228  	name, err := Register(server, p)
   229  	if err != nil {
   230  		t.Fatalf("err: %s", err)
   231  	}
   232  	provider := &ResourceProvider{Client: client, Name: name}
   233  
   234  	expected := []terraform.ResourceType{
   235  		{"foo"},
   236  		{"bar"},
   237  	}
   238  
   239  	p.ResourcesReturn = expected
   240  
   241  	// Resources
   242  	result := provider.Resources()
   243  	if !p.ResourcesCalled {
   244  		t.Fatal("resources should be called")
   245  	}
   246  	if !reflect.DeepEqual(result, expected) {
   247  		t.Fatalf("bad: %#v", result)
   248  	}
   249  }
   250  
   251  func TestResourceProvider_validate(t *testing.T) {
   252  	p := new(terraform.MockResourceProvider)
   253  	client, server := testClientServer(t)
   254  	name, err := Register(server, p)
   255  	if err != nil {
   256  		t.Fatalf("err: %s", err)
   257  	}
   258  	provider := &ResourceProvider{Client: client, Name: name}
   259  
   260  	// Configure
   261  	config := &terraform.ResourceConfig{
   262  		Raw: map[string]interface{}{"foo": "bar"},
   263  	}
   264  	w, e := provider.Validate(config)
   265  	if !p.ValidateCalled {
   266  		t.Fatal("configure should be called")
   267  	}
   268  	if !reflect.DeepEqual(p.ValidateConfig, config) {
   269  		t.Fatalf("bad: %#v", p.ValidateConfig)
   270  	}
   271  	if w != nil {
   272  		t.Fatalf("bad: %#v", w)
   273  	}
   274  	if e != nil {
   275  		t.Fatalf("bad: %#v", e)
   276  	}
   277  }
   278  
   279  func TestResourceProvider_validate_errors(t *testing.T) {
   280  	p := new(terraform.MockResourceProvider)
   281  	p.ValidateReturnErrors = []error{errors.New("foo")}
   282  
   283  	client, server := testClientServer(t)
   284  	name, err := Register(server, p)
   285  	if err != nil {
   286  		t.Fatalf("err: %s", err)
   287  	}
   288  	provider := &ResourceProvider{Client: client, Name: name}
   289  
   290  	// Configure
   291  	config := &terraform.ResourceConfig{
   292  		Raw: map[string]interface{}{"foo": "bar"},
   293  	}
   294  	w, e := provider.Validate(config)
   295  	if !p.ValidateCalled {
   296  		t.Fatal("configure should be called")
   297  	}
   298  	if !reflect.DeepEqual(p.ValidateConfig, config) {
   299  		t.Fatalf("bad: %#v", p.ValidateConfig)
   300  	}
   301  	if w != nil {
   302  		t.Fatalf("bad: %#v", w)
   303  	}
   304  
   305  	if len(e) != 1 {
   306  		t.Fatalf("bad: %#v", e)
   307  	}
   308  	if e[0].Error() != "foo" {
   309  		t.Fatalf("bad: %#v", e)
   310  	}
   311  }
   312  
   313  func TestResourceProvider_validate_warns(t *testing.T) {
   314  	p := new(terraform.MockResourceProvider)
   315  	p.ValidateReturnWarns = []string{"foo"}
   316  
   317  	client, server := testClientServer(t)
   318  	name, err := Register(server, p)
   319  	if err != nil {
   320  		t.Fatalf("err: %s", err)
   321  	}
   322  	provider := &ResourceProvider{Client: client, Name: name}
   323  
   324  	// Configure
   325  	config := &terraform.ResourceConfig{
   326  		Raw: map[string]interface{}{"foo": "bar"},
   327  	}
   328  	w, e := provider.Validate(config)
   329  	if !p.ValidateCalled {
   330  		t.Fatal("configure should be called")
   331  	}
   332  	if !reflect.DeepEqual(p.ValidateConfig, config) {
   333  		t.Fatalf("bad: %#v", p.ValidateConfig)
   334  	}
   335  	if e != nil {
   336  		t.Fatalf("bad: %#v", e)
   337  	}
   338  
   339  	expected := []string{"foo"}
   340  	if !reflect.DeepEqual(w, expected) {
   341  		t.Fatalf("bad: %#v", w)
   342  	}
   343  }
   344  
   345  func TestResourceProvider_validateResource(t *testing.T) {
   346  	p := new(terraform.MockResourceProvider)
   347  	client, server := testClientServer(t)
   348  	name, err := Register(server, p)
   349  	if err != nil {
   350  		t.Fatalf("err: %s", err)
   351  	}
   352  	provider := &ResourceProvider{Client: client, Name: name}
   353  
   354  	// Configure
   355  	config := &terraform.ResourceConfig{
   356  		Raw: map[string]interface{}{"foo": "bar"},
   357  	}
   358  	w, e := provider.ValidateResource("foo", config)
   359  	if !p.ValidateResourceCalled {
   360  		t.Fatal("configure should be called")
   361  	}
   362  	if p.ValidateResourceType != "foo" {
   363  		t.Fatalf("bad: %#v", p.ValidateResourceType)
   364  	}
   365  	if !reflect.DeepEqual(p.ValidateResourceConfig, config) {
   366  		t.Fatalf("bad: %#v", p.ValidateResourceConfig)
   367  	}
   368  	if w != nil {
   369  		t.Fatalf("bad: %#v", w)
   370  	}
   371  	if e != nil {
   372  		t.Fatalf("bad: %#v", e)
   373  	}
   374  }
   375  
   376  func TestResourceProvider_validateResource_errors(t *testing.T) {
   377  	p := new(terraform.MockResourceProvider)
   378  	p.ValidateResourceReturnErrors = []error{errors.New("foo")}
   379  
   380  	client, server := testClientServer(t)
   381  	name, err := Register(server, p)
   382  	if err != nil {
   383  		t.Fatalf("err: %s", err)
   384  	}
   385  	provider := &ResourceProvider{Client: client, Name: name}
   386  
   387  	// Configure
   388  	config := &terraform.ResourceConfig{
   389  		Raw: map[string]interface{}{"foo": "bar"},
   390  	}
   391  	w, e := provider.ValidateResource("foo", config)
   392  	if !p.ValidateResourceCalled {
   393  		t.Fatal("configure should be called")
   394  	}
   395  	if p.ValidateResourceType != "foo" {
   396  		t.Fatalf("bad: %#v", p.ValidateResourceType)
   397  	}
   398  	if !reflect.DeepEqual(p.ValidateResourceConfig, config) {
   399  		t.Fatalf("bad: %#v", p.ValidateResourceConfig)
   400  	}
   401  	if w != nil {
   402  		t.Fatalf("bad: %#v", w)
   403  	}
   404  
   405  	if len(e) != 1 {
   406  		t.Fatalf("bad: %#v", e)
   407  	}
   408  	if e[0].Error() != "foo" {
   409  		t.Fatalf("bad: %#v", e)
   410  	}
   411  }
   412  
   413  func TestResourceProvider_validateResource_warns(t *testing.T) {
   414  	p := new(terraform.MockResourceProvider)
   415  	p.ValidateResourceReturnWarns = []string{"foo"}
   416  
   417  	client, server := testClientServer(t)
   418  	name, err := Register(server, p)
   419  	if err != nil {
   420  		t.Fatalf("err: %s", err)
   421  	}
   422  	provider := &ResourceProvider{Client: client, Name: name}
   423  
   424  	// Configure
   425  	config := &terraform.ResourceConfig{
   426  		Raw: map[string]interface{}{"foo": "bar"},
   427  	}
   428  	w, e := provider.ValidateResource("foo", config)
   429  	if !p.ValidateResourceCalled {
   430  		t.Fatal("configure should be called")
   431  	}
   432  	if p.ValidateResourceType != "foo" {
   433  		t.Fatalf("bad: %#v", p.ValidateResourceType)
   434  	}
   435  	if !reflect.DeepEqual(p.ValidateResourceConfig, config) {
   436  		t.Fatalf("bad: %#v", p.ValidateResourceConfig)
   437  	}
   438  	if e != nil {
   439  		t.Fatalf("bad: %#v", e)
   440  	}
   441  
   442  	expected := []string{"foo"}
   443  	if !reflect.DeepEqual(w, expected) {
   444  		t.Fatalf("bad: %#v", w)
   445  	}
   446  }