github.com/simonswine/terraform@v0.9.0-beta2/command/init_test.go (about) 1 package command 2 3 import ( 4 "io/ioutil" 5 "os" 6 "path/filepath" 7 "strings" 8 "testing" 9 10 "github.com/hashicorp/terraform/helper/copy" 11 "github.com/mitchellh/cli" 12 ) 13 14 func TestInit(t *testing.T) { 15 dir := tempDir(t) 16 17 ui := new(cli.MockUi) 18 c := &InitCommand{ 19 Meta: Meta{ 20 ContextOpts: testCtxConfig(testProvider()), 21 Ui: ui, 22 }, 23 } 24 25 args := []string{ 26 testFixturePath("init"), 27 dir, 28 } 29 if code := c.Run(args); code != 0 { 30 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 31 } 32 33 if _, err := os.Stat(filepath.Join(dir, "hello.tf")); err != nil { 34 t.Fatalf("err: %s", err) 35 } 36 } 37 38 func TestInit_cwd(t *testing.T) { 39 dir := tempDir(t) 40 if err := os.MkdirAll(dir, 0755); err != nil { 41 t.Fatalf("err: %s", err) 42 } 43 44 // Change to the temporary directory 45 cwd, err := os.Getwd() 46 if err != nil { 47 t.Fatalf("err: %s", err) 48 } 49 if err := os.Chdir(dir); err != nil { 50 t.Fatalf("err: %s", err) 51 } 52 defer os.Chdir(cwd) 53 54 ui := new(cli.MockUi) 55 c := &InitCommand{ 56 Meta: Meta{ 57 ContextOpts: testCtxConfig(testProvider()), 58 Ui: ui, 59 }, 60 } 61 62 args := []string{ 63 testFixturePath("init"), 64 } 65 if code := c.Run(args); code != 0 { 66 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 67 } 68 69 if _, err := os.Stat("hello.tf"); err != nil { 70 t.Fatalf("err: %s", err) 71 } 72 } 73 74 func TestInit_empty(t *testing.T) { 75 // Create a temporary working directory that is empty 76 td := tempDir(t) 77 os.MkdirAll(td, 0755) 78 defer os.RemoveAll(td) 79 defer testChdir(t, td)() 80 81 ui := new(cli.MockUi) 82 c := &InitCommand{ 83 Meta: Meta{ 84 ContextOpts: testCtxConfig(testProvider()), 85 Ui: ui, 86 }, 87 } 88 89 args := []string{} 90 if code := c.Run(args); code != 0 { 91 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 92 } 93 } 94 95 func TestInit_multipleArgs(t *testing.T) { 96 ui := new(cli.MockUi) 97 c := &InitCommand{ 98 Meta: Meta{ 99 ContextOpts: testCtxConfig(testProvider()), 100 Ui: ui, 101 }, 102 } 103 104 args := []string{ 105 "bad", 106 "bad", 107 } 108 if code := c.Run(args); code != 1 { 109 t.Fatalf("bad: \n%s", ui.OutputWriter.String()) 110 } 111 } 112 113 // https://github.com/hashicorp/terraform/issues/518 114 func TestInit_dstInSrc(t *testing.T) { 115 dir := tempDir(t) 116 if err := os.MkdirAll(dir, 0755); err != nil { 117 t.Fatalf("err: %s", err) 118 } 119 120 // Change to the temporary directory 121 cwd, err := os.Getwd() 122 if err != nil { 123 t.Fatalf("err: %s", err) 124 } 125 if err := os.Chdir(dir); err != nil { 126 t.Fatalf("err: %s", err) 127 } 128 defer os.Chdir(cwd) 129 130 if _, err := os.Create("issue518.tf"); err != nil { 131 t.Fatalf("err: %s", err) 132 } 133 134 ui := new(cli.MockUi) 135 c := &InitCommand{ 136 Meta: Meta{ 137 ContextOpts: testCtxConfig(testProvider()), 138 Ui: ui, 139 }, 140 } 141 142 args := []string{ 143 ".", 144 "foo", 145 } 146 if code := c.Run(args); code != 0 { 147 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 148 } 149 150 if _, err := os.Stat(filepath.Join(dir, "foo", "issue518.tf")); err != nil { 151 t.Fatalf("err: %s", err) 152 } 153 } 154 155 func TestInit_get(t *testing.T) { 156 // Create a temporary working directory that is empty 157 td := tempDir(t) 158 copy.CopyDir(testFixturePath("init-get"), td) 159 defer os.RemoveAll(td) 160 defer testChdir(t, td)() 161 162 ui := new(cli.MockUi) 163 c := &InitCommand{ 164 Meta: Meta{ 165 ContextOpts: testCtxConfig(testProvider()), 166 Ui: ui, 167 }, 168 } 169 170 args := []string{} 171 if code := c.Run(args); code != 0 { 172 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 173 } 174 175 // Check output 176 output := ui.OutputWriter.String() 177 if !strings.Contains(output, "Get: file://") { 178 t.Fatalf("doesn't look like get: %s", output) 179 } 180 } 181 182 func TestInit_copyGet(t *testing.T) { 183 // Create a temporary working directory that is empty 184 td := tempDir(t) 185 os.MkdirAll(td, 0755) 186 defer os.RemoveAll(td) 187 defer testChdir(t, td)() 188 189 ui := new(cli.MockUi) 190 c := &InitCommand{ 191 Meta: Meta{ 192 ContextOpts: testCtxConfig(testProvider()), 193 Ui: ui, 194 }, 195 } 196 197 args := []string{ 198 testFixturePath("init-get"), 199 } 200 if code := c.Run(args); code != 0 { 201 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 202 } 203 204 // Check copy 205 if _, err := os.Stat("main.tf"); err != nil { 206 t.Fatalf("err: %s", err) 207 } 208 209 output := ui.OutputWriter.String() 210 if !strings.Contains(output, "Get: file://") { 211 t.Fatalf("doesn't look like get: %s", output) 212 } 213 } 214 215 func TestInit_backend(t *testing.T) { 216 // Create a temporary working directory that is empty 217 td := tempDir(t) 218 copy.CopyDir(testFixturePath("init-backend"), td) 219 defer os.RemoveAll(td) 220 defer testChdir(t, td)() 221 222 ui := new(cli.MockUi) 223 c := &InitCommand{ 224 Meta: Meta{ 225 ContextOpts: testCtxConfig(testProvider()), 226 Ui: ui, 227 }, 228 } 229 230 args := []string{} 231 if code := c.Run(args); code != 0 { 232 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 233 } 234 235 if _, err := os.Stat(filepath.Join(DefaultDataDir, DefaultStateFilename)); err != nil { 236 t.Fatalf("err: %s", err) 237 } 238 } 239 240 func TestInit_backendUnset(t *testing.T) { 241 // Create a temporary working directory that is empty 242 td := tempDir(t) 243 copy.CopyDir(testFixturePath("init-backend"), td) 244 defer os.RemoveAll(td) 245 defer testChdir(t, td)() 246 247 { 248 ui := new(cli.MockUi) 249 c := &InitCommand{ 250 Meta: Meta{ 251 ContextOpts: testCtxConfig(testProvider()), 252 Ui: ui, 253 }, 254 } 255 256 // Init 257 args := []string{} 258 if code := c.Run(args); code != 0 { 259 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 260 } 261 262 if _, err := os.Stat(filepath.Join(DefaultDataDir, DefaultStateFilename)); err != nil { 263 t.Fatalf("err: %s", err) 264 } 265 } 266 267 { 268 // Unset 269 if err := ioutil.WriteFile("main.tf", []byte(""), 0644); err != nil { 270 t.Fatalf("err: %s", err) 271 } 272 273 // Run it again 274 defer testInteractiveInput(t, []string{"yes", "yes"})() 275 276 ui := new(cli.MockUi) 277 c := &InitCommand{ 278 Meta: Meta{ 279 ContextOpts: testCtxConfig(testProvider()), 280 Ui: ui, 281 }, 282 } 283 284 args := []string{} 285 if code := c.Run(args); code != 0 { 286 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 287 } 288 289 s := testStateRead(t, filepath.Join( 290 DefaultDataDir, DefaultStateFilename)) 291 if !s.Backend.Empty() { 292 t.Fatal("should not have backend config") 293 } 294 } 295 } 296 297 func TestInit_backendConfigFile(t *testing.T) { 298 // Create a temporary working directory that is empty 299 td := tempDir(t) 300 copy.CopyDir(testFixturePath("init-backend-config-file"), td) 301 defer os.RemoveAll(td) 302 defer testChdir(t, td)() 303 304 ui := new(cli.MockUi) 305 c := &InitCommand{ 306 Meta: Meta{ 307 ContextOpts: testCtxConfig(testProvider()), 308 Ui: ui, 309 }, 310 } 311 312 args := []string{"-backend-config", "input.config"} 313 if code := c.Run(args); code != 0 { 314 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 315 } 316 317 // Read our saved backend config and verify we have our settings 318 state := testStateRead(t, filepath.Join(DefaultDataDir, DefaultStateFilename)) 319 if v := state.Backend.Config["path"]; v != "hello" { 320 t.Fatalf("bad: %#v", v) 321 } 322 } 323 324 func TestInit_copyBackendDst(t *testing.T) { 325 // Create a temporary working directory that is empty 326 td := tempDir(t) 327 os.MkdirAll(td, 0755) 328 defer os.RemoveAll(td) 329 defer testChdir(t, td)() 330 331 ui := new(cli.MockUi) 332 c := &InitCommand{ 333 Meta: Meta{ 334 ContextOpts: testCtxConfig(testProvider()), 335 Ui: ui, 336 }, 337 } 338 339 args := []string{ 340 testFixturePath("init-backend"), 341 "dst", 342 } 343 if code := c.Run(args); code != 0 { 344 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 345 } 346 347 if _, err := os.Stat(filepath.Join( 348 "dst", DefaultDataDir, DefaultStateFilename)); err != nil { 349 t.Fatalf("err: %s", err) 350 } 351 } 352 353 /* 354 func TestInit_remoteState(t *testing.T) { 355 tmp, cwd := testCwd(t) 356 defer testFixCwd(t, tmp, cwd) 357 358 s := terraform.NewState() 359 conf, srv := testRemoteState(t, s, 200) 360 defer srv.Close() 361 362 ui := new(cli.MockUi) 363 c := &InitCommand{ 364 Meta: Meta{ 365 ContextOpts: testCtxConfig(testProvider()), 366 Ui: ui, 367 }, 368 } 369 370 args := []string{ 371 "-backend", "HTTP", 372 "-backend-config", "address=" + conf.Config["address"], 373 testFixturePath("init"), 374 tmp, 375 } 376 if code := c.Run(args); code != 0 { 377 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 378 } 379 380 if _, err := os.Stat(filepath.Join(tmp, "hello.tf")); err != nil { 381 t.Fatalf("err: %s", err) 382 } 383 384 if _, err := os.Stat(filepath.Join(tmp, DefaultDataDir, DefaultStateFilename)); err != nil { 385 t.Fatalf("missing state: %s", err) 386 } 387 } 388 389 func TestInit_remoteStateSubdir(t *testing.T) { 390 tmp, cwd := testCwd(t) 391 defer testFixCwd(t, tmp, cwd) 392 subdir := filepath.Join(tmp, "subdir") 393 394 s := terraform.NewState() 395 conf, srv := testRemoteState(t, s, 200) 396 defer srv.Close() 397 398 ui := new(cli.MockUi) 399 c := &InitCommand{ 400 Meta: Meta{ 401 ContextOpts: testCtxConfig(testProvider()), 402 Ui: ui, 403 }, 404 } 405 406 args := []string{ 407 "-backend", "http", 408 "-backend-config", "address=" + conf.Config["address"], 409 testFixturePath("init"), 410 subdir, 411 } 412 if code := c.Run(args); code != 0 { 413 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 414 } 415 416 if _, err := os.Stat(filepath.Join(subdir, "hello.tf")); err != nil { 417 t.Fatalf("err: %s", err) 418 } 419 420 if _, err := os.Stat(filepath.Join(subdir, DefaultDataDir, DefaultStateFilename)); err != nil { 421 t.Fatalf("missing state: %s", err) 422 } 423 } 424 425 func TestInit_remoteStateWithLocal(t *testing.T) { 426 tmp, cwd := testCwd(t) 427 defer testFixCwd(t, tmp, cwd) 428 429 statePath := filepath.Join(tmp, DefaultStateFilename) 430 431 // Write some state 432 f, err := os.Create(statePath) 433 if err != nil { 434 t.Fatalf("err: %s", err) 435 } 436 err = terraform.WriteState(testState(), f) 437 f.Close() 438 if err != nil { 439 t.Fatalf("err: %s", err) 440 } 441 442 ui := new(cli.MockUi) 443 c := &InitCommand{ 444 Meta: Meta{ 445 ContextOpts: testCtxConfig(testProvider()), 446 Ui: ui, 447 }, 448 } 449 450 args := []string{ 451 "-backend", "http", 452 "-backend-config", "address=http://google.com", 453 testFixturePath("init"), 454 } 455 if code := c.Run(args); code == 0 { 456 t.Fatalf("should have failed: \n%s", ui.OutputWriter.String()) 457 } 458 } 459 460 func TestInit_remoteStateWithRemote(t *testing.T) { 461 tmp, cwd := testCwd(t) 462 defer testFixCwd(t, tmp, cwd) 463 464 statePath := filepath.Join(tmp, DefaultDataDir, DefaultStateFilename) 465 if err := os.MkdirAll(filepath.Dir(statePath), 0755); err != nil { 466 t.Fatalf("err: %s", err) 467 } 468 469 // Write some state 470 f, err := os.Create(statePath) 471 if err != nil { 472 t.Fatalf("err: %s", err) 473 } 474 err = terraform.WriteState(testState(), f) 475 f.Close() 476 if err != nil { 477 t.Fatalf("err: %s", err) 478 } 479 480 ui := new(cli.MockUi) 481 c := &InitCommand{ 482 Meta: Meta{ 483 ContextOpts: testCtxConfig(testProvider()), 484 Ui: ui, 485 }, 486 } 487 488 args := []string{ 489 "-backend", "http", 490 "-backend-config", "address=http://google.com", 491 testFixturePath("init"), 492 } 493 if code := c.Run(args); code == 0 { 494 t.Fatalf("should have failed: \n%s", ui.OutputWriter.String()) 495 } 496 } 497 */