github.com/pmcatominey/terraform@v0.7.0-rc2.0.20160708105029-1401a52a5cc5/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 }