github.com/renier/terraform@v0.7.8-0.20161024133817-eb8a9ef5471a/terraform/eval_validate_test.go (about)

     1  package terraform
     2  
     3  import (
     4  	"errors"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/terraform/config"
     9  )
    10  
    11  func TestEvalValidateResource_managedResource(t *testing.T) {
    12  	mp := testProvider("aws")
    13  	mp.ValidateResourceFn = func(rt string, c *ResourceConfig) (ws []string, es []error) {
    14  		expected := "aws_instance"
    15  		if rt != expected {
    16  			t.Fatalf("expected: %s, got: %s", expected, rt)
    17  		}
    18  		expected = "bar"
    19  		val, _ := c.Get("foo")
    20  		if val != expected {
    21  			t.Fatalf("expected: %s, got: %s", expected, val)
    22  		}
    23  		return
    24  	}
    25  
    26  	p := ResourceProvider(mp)
    27  	rc := &ResourceConfig{
    28  		Raw: map[string]interface{}{"foo": "bar"},
    29  	}
    30  	node := &EvalValidateResource{
    31  		Provider:     &p,
    32  		Config:       &rc,
    33  		ResourceName: "foo",
    34  		ResourceType: "aws_instance",
    35  		ResourceMode: config.ManagedResourceMode,
    36  	}
    37  
    38  	_, err := node.Eval(&MockEvalContext{})
    39  	if err != nil {
    40  		t.Fatalf("err: %s", err)
    41  	}
    42  
    43  	if !mp.ValidateResourceCalled {
    44  		t.Fatal("Expected ValidateResource to be called, but it was not!")
    45  	}
    46  }
    47  
    48  func TestEvalValidateResource_dataSource(t *testing.T) {
    49  	mp := testProvider("aws")
    50  	mp.ValidateDataSourceFn = func(rt string, c *ResourceConfig) (ws []string, es []error) {
    51  		expected := "aws_ami"
    52  		if rt != expected {
    53  			t.Fatalf("expected: %s, got: %s", expected, rt)
    54  		}
    55  		expected = "bar"
    56  		val, _ := c.Get("foo")
    57  		if val != expected {
    58  			t.Fatalf("expected: %s, got: %s", expected, val)
    59  		}
    60  		return
    61  	}
    62  
    63  	p := ResourceProvider(mp)
    64  	rc := &ResourceConfig{
    65  		Raw: map[string]interface{}{"foo": "bar"},
    66  	}
    67  	node := &EvalValidateResource{
    68  		Provider:     &p,
    69  		Config:       &rc,
    70  		ResourceName: "foo",
    71  		ResourceType: "aws_ami",
    72  		ResourceMode: config.DataResourceMode,
    73  	}
    74  
    75  	_, err := node.Eval(&MockEvalContext{})
    76  	if err != nil {
    77  		t.Fatalf("err: %s", err)
    78  	}
    79  
    80  	if !mp.ValidateDataSourceCalled {
    81  		t.Fatal("Expected ValidateDataSource to be called, but it was not!")
    82  	}
    83  }
    84  
    85  func TestEvalValidateResource_validReturnsNilError(t *testing.T) {
    86  	mp := testProvider("aws")
    87  	mp.ValidateResourceFn = func(rt string, c *ResourceConfig) (ws []string, es []error) {
    88  		return
    89  	}
    90  
    91  	p := ResourceProvider(mp)
    92  	rc := &ResourceConfig{}
    93  	node := &EvalValidateResource{
    94  		Provider:     &p,
    95  		Config:       &rc,
    96  		ResourceName: "foo",
    97  		ResourceType: "aws_instance",
    98  		ResourceMode: config.ManagedResourceMode,
    99  	}
   100  
   101  	_, err := node.Eval(&MockEvalContext{})
   102  	if err != nil {
   103  		t.Fatalf("Expected nil error, got: %s", err)
   104  	}
   105  }
   106  
   107  func TestEvalValidateResource_warningsAndErrorsPassedThrough(t *testing.T) {
   108  	mp := testProvider("aws")
   109  	mp.ValidateResourceFn = func(rt string, c *ResourceConfig) (ws []string, es []error) {
   110  		ws = append(ws, "warn")
   111  		es = append(es, errors.New("err"))
   112  		return
   113  	}
   114  
   115  	p := ResourceProvider(mp)
   116  	rc := &ResourceConfig{}
   117  	node := &EvalValidateResource{
   118  		Provider:     &p,
   119  		Config:       &rc,
   120  		ResourceName: "foo",
   121  		ResourceType: "aws_instance",
   122  		ResourceMode: config.ManagedResourceMode,
   123  	}
   124  
   125  	_, err := node.Eval(&MockEvalContext{})
   126  	if err == nil {
   127  		t.Fatal("Expected an error, got none!")
   128  	}
   129  
   130  	verr := err.(*EvalValidateError)
   131  	if len(verr.Warnings) != 1 || verr.Warnings[0] != "warn" {
   132  		t.Fatalf("Expected 1 warning 'warn', got: %#v", verr.Warnings)
   133  	}
   134  	if len(verr.Errors) != 1 || verr.Errors[0].Error() != "err" {
   135  		t.Fatalf("Expected 1 error 'err', got: %#v", verr.Errors)
   136  	}
   137  }
   138  
   139  func TestEvalValidateResource_checksResourceName(t *testing.T) {
   140  	mp := testProvider("aws")
   141  	p := ResourceProvider(mp)
   142  	rc := &ResourceConfig{}
   143  	node := &EvalValidateResource{
   144  		Provider:     &p,
   145  		Config:       &rc,
   146  		ResourceName: "bad*name",
   147  		ResourceType: "aws_instance",
   148  		ResourceMode: config.ManagedResourceMode,
   149  	}
   150  
   151  	_, err := node.Eval(&MockEvalContext{})
   152  	if err == nil {
   153  		t.Fatal("Expected an error, got none!")
   154  	}
   155  	expectErr := "resource name can only contain"
   156  	if !strings.Contains(err.Error(), expectErr) {
   157  		t.Fatalf("Expected err: %s to contain %s", err, expectErr)
   158  	}
   159  }
   160  
   161  func TestEvalValidateResource_ignoreWarnings(t *testing.T) {
   162  	mp := testProvider("aws")
   163  	mp.ValidateResourceFn = func(rt string, c *ResourceConfig) (ws []string, es []error) {
   164  		ws = append(ws, "warn")
   165  		return
   166  	}
   167  
   168  	p := ResourceProvider(mp)
   169  	rc := &ResourceConfig{}
   170  	node := &EvalValidateResource{
   171  		Provider:     &p,
   172  		Config:       &rc,
   173  		ResourceName: "foo",
   174  		ResourceType: "aws_instance",
   175  		ResourceMode: config.ManagedResourceMode,
   176  
   177  		IgnoreWarnings: true,
   178  	}
   179  
   180  	_, err := node.Eval(&MockEvalContext{})
   181  	if err != nil {
   182  		t.Fatalf("Expected no error, got: %s", err)
   183  	}
   184  }