github.com/adamar/terraform@v0.2.2-0.20141016210445-2e703afdad0e/config/loader_test.go (about) 1 package config 2 3 import ( 4 "path/filepath" 5 "strings" 6 "testing" 7 ) 8 9 func TestIsEmptyDir(t *testing.T) { 10 val, err := IsEmptyDir(fixtureDir) 11 if err != nil { 12 t.Fatalf("err: %s", err) 13 } 14 if val { 15 t.Fatal("should not be empty") 16 } 17 } 18 19 func TestIsEmptyDir_noExist(t *testing.T) { 20 val, err := IsEmptyDir(filepath.Join(fixtureDir, "nopenopenope")) 21 if err != nil { 22 t.Fatalf("err: %s", err) 23 } 24 if !val { 25 t.Fatal("should be empty") 26 } 27 } 28 29 func TestIsEmptyDir_noConfigs(t *testing.T) { 30 val, err := IsEmptyDir(filepath.Join(fixtureDir, "dir-empty")) 31 if err != nil { 32 t.Fatalf("err: %s", err) 33 } 34 if !val { 35 t.Fatal("should be empty") 36 } 37 } 38 39 func TestLoad_badType(t *testing.T) { 40 _, err := Load(filepath.Join(fixtureDir, "bad_type.tf.nope")) 41 if err == nil { 42 t.Fatal("should have error") 43 } 44 } 45 46 func TestLoadBasic(t *testing.T) { 47 c, err := Load(filepath.Join(fixtureDir, "basic.tf")) 48 if err != nil { 49 t.Fatalf("err: %s", err) 50 } 51 52 if c == nil { 53 t.Fatal("config should not be nil") 54 } 55 56 if c.Dir != "" { 57 t.Fatalf("bad: %#v", c.Dir) 58 } 59 60 actual := variablesStr(c.Variables) 61 if actual != strings.TrimSpace(basicVariablesStr) { 62 t.Fatalf("bad:\n%s", actual) 63 } 64 65 actual = providerConfigsStr(c.ProviderConfigs) 66 if actual != strings.TrimSpace(basicProvidersStr) { 67 t.Fatalf("bad:\n%s", actual) 68 } 69 70 actual = resourcesStr(c.Resources) 71 if actual != strings.TrimSpace(basicResourcesStr) { 72 t.Fatalf("bad:\n%s", actual) 73 } 74 75 actual = outputsStr(c.Outputs) 76 if actual != strings.TrimSpace(basicOutputsStr) { 77 t.Fatalf("bad:\n%s", actual) 78 } 79 } 80 81 func TestLoadBasic_empty(t *testing.T) { 82 c, err := Load(filepath.Join(fixtureDir, "empty.tf")) 83 if err != nil { 84 t.Fatalf("err: %s", err) 85 } 86 87 if c == nil { 88 t.Fatal("config should not be nil") 89 } 90 } 91 92 func TestLoadBasic_import(t *testing.T) { 93 // Skip because we disabled importing 94 t.Skip() 95 96 c, err := Load(filepath.Join(fixtureDir, "import.tf")) 97 if err != nil { 98 t.Fatalf("err: %s", err) 99 } 100 101 if c == nil { 102 t.Fatal("config should not be nil") 103 } 104 105 actual := variablesStr(c.Variables) 106 if actual != strings.TrimSpace(importVariablesStr) { 107 t.Fatalf("bad:\n%s", actual) 108 } 109 110 actual = providerConfigsStr(c.ProviderConfigs) 111 if actual != strings.TrimSpace(importProvidersStr) { 112 t.Fatalf("bad:\n%s", actual) 113 } 114 115 actual = resourcesStr(c.Resources) 116 if actual != strings.TrimSpace(importResourcesStr) { 117 t.Fatalf("bad:\n%s", actual) 118 } 119 } 120 121 func TestLoadBasic_json(t *testing.T) { 122 c, err := Load(filepath.Join(fixtureDir, "basic.tf.json")) 123 if err != nil { 124 t.Fatalf("err: %s", err) 125 } 126 127 if c == nil { 128 t.Fatal("config should not be nil") 129 } 130 131 if c.Dir != "" { 132 t.Fatalf("bad: %#v", c.Dir) 133 } 134 135 actual := variablesStr(c.Variables) 136 if actual != strings.TrimSpace(basicVariablesStr) { 137 t.Fatalf("bad:\n%s", actual) 138 } 139 140 actual = providerConfigsStr(c.ProviderConfigs) 141 if actual != strings.TrimSpace(basicProvidersStr) { 142 t.Fatalf("bad:\n%s", actual) 143 } 144 145 actual = resourcesStr(c.Resources) 146 if actual != strings.TrimSpace(basicResourcesStr) { 147 t.Fatalf("bad:\n%s", actual) 148 } 149 150 actual = outputsStr(c.Outputs) 151 if actual != strings.TrimSpace(basicOutputsStr) { 152 t.Fatalf("bad:\n%s", actual) 153 } 154 } 155 156 func TestLoadBasic_modules(t *testing.T) { 157 c, err := Load(filepath.Join(fixtureDir, "modules.tf")) 158 if err != nil { 159 t.Fatalf("err: %s", err) 160 } 161 162 if c == nil { 163 t.Fatal("config should not be nil") 164 } 165 166 if c.Dir != "" { 167 t.Fatalf("bad: %#v", c.Dir) 168 } 169 170 actual := modulesStr(c.Modules) 171 if actual != strings.TrimSpace(modulesModulesStr) { 172 t.Fatalf("bad:\n%s", actual) 173 } 174 } 175 176 func TestLoad_variables(t *testing.T) { 177 c, err := Load(filepath.Join(fixtureDir, "variables.tf")) 178 if err != nil { 179 t.Fatalf("err: %s", err) 180 } 181 if c == nil { 182 t.Fatal("config should not be nil") 183 } 184 185 if c.Dir != "" { 186 t.Fatalf("bad: %#v", c.Dir) 187 } 188 189 actual := variablesStr(c.Variables) 190 if actual != strings.TrimSpace(variablesVariablesStr) { 191 t.Fatalf("bad:\n%s", actual) 192 } 193 } 194 195 func TestLoadDir_basic(t *testing.T) { 196 dir := filepath.Join(fixtureDir, "dir-basic") 197 c, err := LoadDir(dir) 198 if err != nil { 199 t.Fatalf("err: %s", err) 200 } 201 202 if c == nil { 203 t.Fatal("config should not be nil") 204 } 205 206 dirAbs, err := filepath.Abs(dir) 207 if err != nil { 208 t.Fatalf("err: %s", err) 209 } 210 if c.Dir != dirAbs { 211 t.Fatalf("bad: %#v", c.Dir) 212 } 213 214 actual := variablesStr(c.Variables) 215 if actual != strings.TrimSpace(dirBasicVariablesStr) { 216 t.Fatalf("bad:\n%s", actual) 217 } 218 219 actual = providerConfigsStr(c.ProviderConfigs) 220 if actual != strings.TrimSpace(dirBasicProvidersStr) { 221 t.Fatalf("bad:\n%s", actual) 222 } 223 224 actual = resourcesStr(c.Resources) 225 if actual != strings.TrimSpace(dirBasicResourcesStr) { 226 t.Fatalf("bad:\n%s", actual) 227 } 228 229 actual = outputsStr(c.Outputs) 230 if actual != strings.TrimSpace(dirBasicOutputsStr) { 231 t.Fatalf("bad:\n%s", actual) 232 } 233 } 234 235 func TestLoadDir_file(t *testing.T) { 236 _, err := LoadDir(filepath.Join(fixtureDir, "variables.tf")) 237 if err == nil { 238 t.Fatal("should error") 239 } 240 } 241 242 func TestLoadDir_noConfigs(t *testing.T) { 243 _, err := LoadDir(filepath.Join(fixtureDir, "dir-empty")) 244 if err == nil { 245 t.Fatal("should error") 246 } 247 } 248 249 func TestLoadDir_noMerge(t *testing.T) { 250 c, err := LoadDir(filepath.Join(fixtureDir, "dir-merge")) 251 if err != nil { 252 t.Fatalf("err: %s", err) 253 } 254 255 if c == nil { 256 t.Fatal("config should not be nil") 257 } 258 259 if err := c.Validate(); err == nil { 260 t.Fatal("should not be valid") 261 } 262 } 263 264 func TestLoadDir_override(t *testing.T) { 265 c, err := LoadDir(filepath.Join(fixtureDir, "dir-override")) 266 if err != nil { 267 t.Fatalf("err: %s", err) 268 } 269 270 if c == nil { 271 t.Fatal("config should not be nil") 272 } 273 274 actual := variablesStr(c.Variables) 275 if actual != strings.TrimSpace(dirOverrideVariablesStr) { 276 t.Fatalf("bad:\n%s", actual) 277 } 278 279 actual = providerConfigsStr(c.ProviderConfigs) 280 if actual != strings.TrimSpace(dirOverrideProvidersStr) { 281 t.Fatalf("bad:\n%s", actual) 282 } 283 284 actual = resourcesStr(c.Resources) 285 if actual != strings.TrimSpace(dirOverrideResourcesStr) { 286 t.Fatalf("bad:\n%s", actual) 287 } 288 289 actual = outputsStr(c.Outputs) 290 if actual != strings.TrimSpace(dirOverrideOutputsStr) { 291 t.Fatalf("bad:\n%s", actual) 292 } 293 } 294 295 func TestLoad_provisioners(t *testing.T) { 296 c, err := Load(filepath.Join(fixtureDir, "provisioners.tf")) 297 if err != nil { 298 t.Fatalf("err: %s", err) 299 } 300 301 if c == nil { 302 t.Fatal("config should not be nil") 303 } 304 305 actual := resourcesStr(c.Resources) 306 if actual != strings.TrimSpace(provisionerResourcesStr) { 307 t.Fatalf("bad:\n%s", actual) 308 } 309 } 310 311 func TestLoad_connections(t *testing.T) { 312 c, err := Load(filepath.Join(fixtureDir, "connection.tf")) 313 if err != nil { 314 t.Fatalf("err: %s", err) 315 } 316 317 if c == nil { 318 t.Fatal("config should not be nil") 319 } 320 321 actual := resourcesStr(c.Resources) 322 if actual != strings.TrimSpace(connectionResourcesStr) { 323 t.Fatalf("bad:\n%s", actual) 324 } 325 326 // Check for the connection info 327 r := c.Resources[0] 328 if r.Name != "web" && r.Type != "aws_instance" { 329 t.Fatalf("Bad: %#v", r) 330 } 331 332 p1 := r.Provisioners[0] 333 if p1.ConnInfo == nil || len(p1.ConnInfo.Raw) != 2 { 334 t.Fatalf("Bad: %#v", p1.ConnInfo) 335 } 336 if p1.ConnInfo.Raw["user"] != "nobody" { 337 t.Fatalf("Bad: %#v", p1.ConnInfo) 338 } 339 340 p2 := r.Provisioners[1] 341 if p2.ConnInfo == nil || len(p2.ConnInfo.Raw) != 2 { 342 t.Fatalf("Bad: %#v", p2.ConnInfo) 343 } 344 if p2.ConnInfo.Raw["user"] != "root" { 345 t.Fatalf("Bad: %#v", p2.ConnInfo) 346 } 347 } 348 349 func TestLoad_createBeforeDestroy(t *testing.T) { 350 c, err := Load(filepath.Join(fixtureDir, "create-before-destroy.tf")) 351 if err != nil { 352 t.Fatalf("err: %s", err) 353 } 354 355 if c == nil { 356 t.Fatal("config should not be nil") 357 } 358 359 actual := resourcesStr(c.Resources) 360 if actual != strings.TrimSpace(createBeforeDestroyResourcesStr) { 361 t.Fatalf("bad:\n%s", actual) 362 } 363 364 // Check for the flag value 365 r := c.Resources[0] 366 if r.Name != "web" && r.Type != "aws_instance" { 367 t.Fatalf("Bad: %#v", r) 368 } 369 370 // Should enable create before destroy 371 if !r.Lifecycle.CreateBeforeDestroy { 372 t.Fatalf("Bad: %#v", r) 373 } 374 375 r = c.Resources[1] 376 if r.Name != "bar" && r.Type != "aws_instance" { 377 t.Fatalf("Bad: %#v", r) 378 } 379 380 // Should not enable create before destroy 381 if r.Lifecycle.CreateBeforeDestroy { 382 t.Fatalf("Bad: %#v", r) 383 } 384 } 385 386 const basicOutputsStr = ` 387 web_ip 388 vars 389 resource: aws_instance.web.private_ip 390 ` 391 392 const basicProvidersStr = ` 393 aws 394 access_key 395 secret_key 396 do 397 api_key 398 vars 399 user: var.foo 400 ` 401 402 const basicResourcesStr = ` 403 aws_instance[db] (x1) 404 VPC 405 security_groups 406 dependsOn 407 aws_instance.web 408 vars 409 resource: aws_security_group.firewall.*.id 410 aws_instance[web] (x1) 411 ami 412 network_interface 413 security_groups 414 vars 415 resource: aws_security_group.firewall.foo 416 user: var.foo 417 aws_security_group[firewall] (x5) 418 ` 419 420 const basicVariablesStr = ` 421 foo 422 bar 423 bar 424 ` 425 426 const dirBasicOutputsStr = ` 427 web_ip 428 vars 429 resource: aws_instance.web.private_ip 430 ` 431 432 const dirBasicProvidersStr = ` 433 aws 434 access_key 435 secret_key 436 do 437 api_key 438 vars 439 user: var.foo 440 ` 441 442 const dirBasicResourcesStr = ` 443 aws_instance[db] (x1) 444 security_groups 445 vars 446 resource: aws_security_group.firewall.*.id 447 aws_instance[web] (x1) 448 ami 449 network_interface 450 security_groups 451 vars 452 resource: aws_security_group.firewall.foo 453 user: var.foo 454 aws_security_group[firewall] (x5) 455 ` 456 457 const dirBasicVariablesStr = ` 458 foo 459 bar 460 bar 461 ` 462 463 const dirOverrideOutputsStr = ` 464 web_ip 465 vars 466 resource: aws_instance.web.private_ip 467 ` 468 469 const dirOverrideProvidersStr = ` 470 aws 471 access_key 472 secret_key 473 do 474 api_key 475 vars 476 user: var.foo 477 ` 478 479 const dirOverrideResourcesStr = ` 480 aws_instance[db] (x1) 481 ami 482 security_groups 483 aws_instance[web] (x1) 484 ami 485 foo 486 network_interface 487 security_groups 488 vars 489 resource: aws_security_group.firewall.foo 490 user: var.foo 491 aws_security_group[firewall] (x5) 492 ` 493 494 const dirOverrideVariablesStr = ` 495 foo 496 bar 497 bar 498 ` 499 500 const importProvidersStr = ` 501 aws 502 bar 503 foo 504 ` 505 506 const importResourcesStr = ` 507 aws_security_group[db] (x1) 508 aws_security_group[web] (x1) 509 ` 510 511 const importVariablesStr = ` 512 bar (required) 513 <> 514 <> 515 foo 516 bar 517 bar 518 ` 519 520 const modulesModulesStr = ` 521 bar 522 source = baz 523 memory 524 ` 525 526 const provisionerResourcesStr = ` 527 aws_instance[web] (x1) 528 ami 529 security_groups 530 provisioners 531 shell 532 path 533 vars 534 resource: aws_security_group.firewall.foo 535 user: var.foo 536 ` 537 538 const connectionResourcesStr = ` 539 aws_instance[web] (x1) 540 ami 541 security_groups 542 provisioners 543 shell 544 path 545 shell 546 path 547 vars 548 resource: aws_security_group.firewall.foo 549 user: var.foo 550 ` 551 552 const variablesVariablesStr = ` 553 bar 554 <> 555 <> 556 baz 557 foo 558 <> 559 foo (required) 560 <> 561 <> 562 ` 563 564 const createBeforeDestroyResourcesStr = ` 565 aws_instance[bar] (x1) 566 ami 567 aws_instance[web] (x1) 568 ami 569 `