github.com/adamar/terraform@v0.2.2-0.20141016210445-2e703afdad0e/config/interpolate_test.go (about) 1 package config 2 3 import ( 4 "reflect" 5 "strings" 6 "testing" 7 ) 8 9 func TestNewInterpolatedVariable(t *testing.T) { 10 cases := []struct { 11 Input string 12 Result InterpolatedVariable 13 Error bool 14 }{ 15 { 16 "var.foo", 17 &UserVariable{ 18 Name: "foo", 19 key: "var.foo", 20 }, 21 false, 22 }, 23 { 24 "module.foo.bar", 25 &ModuleVariable{ 26 Name: "foo", 27 Field: "bar", 28 key: "module.foo.bar", 29 }, 30 false, 31 }, 32 { 33 "count.index", 34 &CountVariable{ 35 Type: CountValueIndex, 36 key: "count.index", 37 }, 38 false, 39 }, 40 { 41 "count.nope", 42 &CountVariable{ 43 Type: CountValueInvalid, 44 key: "count.nope", 45 }, 46 false, 47 }, 48 { 49 "path.module", 50 &PathVariable{ 51 Type: PathValueModule, 52 key: "path.module", 53 }, 54 false, 55 }, 56 } 57 58 for i, tc := range cases { 59 actual, err := NewInterpolatedVariable(tc.Input) 60 if (err != nil) != tc.Error { 61 t.Fatalf("%d. Error: %s", i, err) 62 } 63 if !reflect.DeepEqual(actual, tc.Result) { 64 t.Fatalf("%d bad: %#v", i, actual) 65 } 66 } 67 } 68 69 func TestNewResourceVariable(t *testing.T) { 70 v, err := NewResourceVariable("foo.bar.baz") 71 if err != nil { 72 t.Fatalf("err: %s", err) 73 } 74 75 if v.Type != "foo" { 76 t.Fatalf("bad: %#v", v) 77 } 78 if v.Name != "bar" { 79 t.Fatalf("bad: %#v", v) 80 } 81 if v.Field != "baz" { 82 t.Fatalf("bad: %#v", v) 83 } 84 if v.Multi { 85 t.Fatal("should not be multi") 86 } 87 88 if v.FullKey() != "foo.bar.baz" { 89 t.Fatalf("bad: %#v", v) 90 } 91 } 92 93 func TestNewUserVariable(t *testing.T) { 94 v, err := NewUserVariable("var.bar") 95 if err != nil { 96 t.Fatalf("err: %s", err) 97 } 98 99 if v.Name != "bar" { 100 t.Fatalf("bad: %#v", v.Name) 101 } 102 if v.FullKey() != "var.bar" { 103 t.Fatalf("bad: %#v", v) 104 } 105 } 106 107 func TestNewUserVariable_map(t *testing.T) { 108 v, err := NewUserVariable("var.bar.baz") 109 if err != nil { 110 t.Fatalf("err: %s", err) 111 } 112 113 if v.Name != "bar" { 114 t.Fatalf("bad: %#v", v.Name) 115 } 116 if v.Elem != "baz" { 117 t.Fatalf("bad: %#v", v.Elem) 118 } 119 if v.FullKey() != "var.bar.baz" { 120 t.Fatalf("bad: %#v", v) 121 } 122 } 123 124 func TestFunctionInterpolation_impl(t *testing.T) { 125 var _ Interpolation = new(FunctionInterpolation) 126 } 127 128 func TestFunctionInterpolation(t *testing.T) { 129 v1, err := NewInterpolatedVariable("var.foo") 130 if err != nil { 131 t.Fatalf("err: %s", err) 132 } 133 134 v2, err := NewInterpolatedVariable("var.bar") 135 if err != nil { 136 t.Fatalf("err: %s", err) 137 } 138 139 fn := func(vs map[string]string, args ...string) (string, error) { 140 return strings.Join(args, " "), nil 141 } 142 143 i := &FunctionInterpolation{ 144 Func: fn, 145 Args: []Interpolation{ 146 &VariableInterpolation{Variable: v1}, 147 &VariableInterpolation{Variable: v2}, 148 }, 149 } 150 151 expected := map[string]InterpolatedVariable{ 152 "var.foo": v1, 153 "var.bar": v2, 154 } 155 if !reflect.DeepEqual(i.Variables(), expected) { 156 t.Fatalf("bad: %#v", i.Variables()) 157 } 158 159 actual, err := i.Interpolate(map[string]string{ 160 "var.foo": "bar", 161 "var.bar": "baz", 162 }) 163 if err != nil { 164 t.Fatalf("err: %s", err) 165 } 166 167 if actual != "bar baz" { 168 t.Fatalf("bad: %#v", actual) 169 } 170 } 171 172 func TestLiteralInterpolation_impl(t *testing.T) { 173 var _ Interpolation = new(LiteralInterpolation) 174 } 175 176 func TestLiteralInterpolation(t *testing.T) { 177 i := &LiteralInterpolation{ 178 Literal: "bar", 179 } 180 181 if i.Variables() != nil { 182 t.Fatalf("bad: %#v", i.Variables()) 183 } 184 185 actual, err := i.Interpolate(nil) 186 if err != nil { 187 t.Fatalf("err: %s", err) 188 } 189 190 if actual != "bar" { 191 t.Fatalf("bad: %#v", actual) 192 } 193 } 194 195 func TestResourceVariable_impl(t *testing.T) { 196 var _ InterpolatedVariable = new(ResourceVariable) 197 } 198 199 func TestResourceVariable_Multi(t *testing.T) { 200 v, err := NewResourceVariable("foo.bar.*.baz") 201 if err != nil { 202 t.Fatalf("err: %s", err) 203 } 204 205 if v.Type != "foo" { 206 t.Fatalf("bad: %#v", v) 207 } 208 if v.Name != "bar" { 209 t.Fatalf("bad: %#v", v) 210 } 211 if v.Field != "baz" { 212 t.Fatalf("bad: %#v", v) 213 } 214 if !v.Multi { 215 t.Fatal("should be multi") 216 } 217 } 218 219 func TestResourceVariable_MultiIndex(t *testing.T) { 220 cases := []struct { 221 Input string 222 Index int 223 Field string 224 }{ 225 {"foo.bar.*.baz", -1, "baz"}, 226 {"foo.bar.0.baz", 0, "baz"}, 227 {"foo.bar.5.baz", 5, "baz"}, 228 } 229 230 for _, tc := range cases { 231 v, err := NewResourceVariable(tc.Input) 232 if err != nil { 233 t.Fatalf("err: %s", err) 234 } 235 if !v.Multi { 236 t.Fatalf("should be multi: %s", tc.Input) 237 } 238 if v.Index != tc.Index { 239 t.Fatalf("bad: %d\n\n%s", v.Index, tc.Input) 240 } 241 if v.Field != tc.Field { 242 t.Fatalf("bad: %s\n\n%s", v.Field, tc.Input) 243 } 244 } 245 } 246 247 func TestUserVariable_impl(t *testing.T) { 248 var _ InterpolatedVariable = new(UserVariable) 249 } 250 251 func TestVariableInterpolation_impl(t *testing.T) { 252 var _ Interpolation = new(VariableInterpolation) 253 } 254 255 func TestVariableInterpolation(t *testing.T) { 256 uv, err := NewUserVariable("var.foo") 257 if err != nil { 258 t.Fatalf("err: %s", err) 259 } 260 261 i := &VariableInterpolation{Variable: uv} 262 263 expected := map[string]InterpolatedVariable{"var.foo": uv} 264 if !reflect.DeepEqual(i.Variables(), expected) { 265 t.Fatalf("bad: %#v", i.Variables()) 266 } 267 268 actual, err := i.Interpolate(map[string]string{ 269 "var.foo": "bar", 270 }) 271 if err != nil { 272 t.Fatalf("err: %s", err) 273 } 274 275 if actual != "bar" { 276 t.Fatalf("bad: %#v", actual) 277 } 278 } 279 280 func TestVariableInterpolation_missing(t *testing.T) { 281 uv, err := NewUserVariable("var.foo") 282 if err != nil { 283 t.Fatalf("err: %s", err) 284 } 285 286 i := &VariableInterpolation{Variable: uv} 287 _, err = i.Interpolate(map[string]string{ 288 "var.bar": "bar", 289 }) 290 if err == nil { 291 t.Fatal("should error") 292 } 293 }