github.com/ctrox/terraform@v0.11.12-beta1/command/output_test.go (about) 1 package command 2 3 import ( 4 "os" 5 "path/filepath" 6 "strings" 7 "testing" 8 9 "github.com/hashicorp/terraform/terraform" 10 "github.com/mitchellh/cli" 11 ) 12 13 func TestOutput(t *testing.T) { 14 originalState := &terraform.State{ 15 Modules: []*terraform.ModuleState{ 16 { 17 Path: []string{"root"}, 18 Outputs: map[string]*terraform.OutputState{ 19 "foo": { 20 Value: "bar", 21 Type: "string", 22 }, 23 }, 24 }, 25 }, 26 } 27 28 statePath := testStateFile(t, originalState) 29 30 ui := new(cli.MockUi) 31 c := &OutputCommand{ 32 Meta: Meta{ 33 testingOverrides: metaOverridesForProvider(testProvider()), 34 Ui: ui, 35 }, 36 } 37 38 args := []string{ 39 "-state", statePath, 40 "foo", 41 } 42 if code := c.Run(args); code != 0 { 43 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 44 } 45 46 actual := strings.TrimSpace(ui.OutputWriter.String()) 47 if actual != "bar" { 48 t.Fatalf("bad: %#v", actual) 49 } 50 } 51 52 func TestModuleOutput(t *testing.T) { 53 originalState := &terraform.State{ 54 Modules: []*terraform.ModuleState{ 55 { 56 Path: []string{"root"}, 57 Outputs: map[string]*terraform.OutputState{ 58 "foo": { 59 Value: "bar", 60 Type: "string", 61 }, 62 }, 63 }, 64 { 65 Path: []string{"root", "my_module"}, 66 Outputs: map[string]*terraform.OutputState{ 67 "blah": { 68 Value: "tastatur", 69 Type: "string", 70 }, 71 }, 72 }, 73 }, 74 } 75 76 statePath := testStateFile(t, originalState) 77 78 ui := new(cli.MockUi) 79 c := &OutputCommand{ 80 Meta: Meta{ 81 testingOverrides: metaOverridesForProvider(testProvider()), 82 Ui: ui, 83 }, 84 } 85 86 args := []string{ 87 "-state", statePath, 88 "-module", "my_module", 89 "blah", 90 } 91 92 if code := c.Run(args); code != 0 { 93 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 94 } 95 96 actual := strings.TrimSpace(ui.OutputWriter.String()) 97 if actual != "tastatur" { 98 t.Fatalf("bad: %#v", actual) 99 } 100 } 101 102 func TestModuleOutputs(t *testing.T) { 103 originalState := &terraform.State{ 104 Modules: []*terraform.ModuleState{ 105 { 106 Path: []string{"root"}, 107 Outputs: map[string]*terraform.OutputState{ 108 "foo": { 109 Value: "bar", 110 Type: "string", 111 }, 112 }, 113 }, 114 { 115 Path: []string{"root", "my_module"}, 116 Outputs: map[string]*terraform.OutputState{ 117 "blah": { 118 Value: "tastatur", 119 Type: "string", 120 }, 121 }, 122 }, 123 }, 124 } 125 126 statePath := testStateFile(t, originalState) 127 128 ui := new(cli.MockUi) 129 c := &OutputCommand{ 130 Meta: Meta{ 131 testingOverrides: metaOverridesForProvider(testProvider()), 132 Ui: ui, 133 }, 134 } 135 136 args := []string{ 137 "-state", statePath, 138 "-module", "my_module", 139 } 140 141 if code := c.Run(args); code != 0 { 142 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 143 } 144 145 actual := strings.TrimSpace(ui.OutputWriter.String()) 146 if actual != "blah = tastatur" { 147 t.Fatalf("bad: %#v", actual) 148 } 149 } 150 151 func TestOutput_nestedListAndMap(t *testing.T) { 152 originalState := &terraform.State{ 153 Modules: []*terraform.ModuleState{ 154 { 155 Path: []string{"root"}, 156 Outputs: map[string]*terraform.OutputState{ 157 "foo": { 158 Value: []interface{}{ 159 map[string]interface{}{ 160 "key": "value", 161 "key2": "value2", 162 }, 163 map[string]interface{}{ 164 "key": "value", 165 }, 166 }, 167 Type: "list", 168 }, 169 }, 170 }, 171 }, 172 } 173 174 statePath := testStateFile(t, originalState) 175 176 ui := new(cli.MockUi) 177 c := &OutputCommand{ 178 Meta: Meta{ 179 testingOverrides: metaOverridesForProvider(testProvider()), 180 Ui: ui, 181 }, 182 } 183 184 args := []string{ 185 "-state", statePath, 186 } 187 if code := c.Run(args); code != 0 { 188 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 189 } 190 191 actual := strings.TrimSpace(ui.OutputWriter.String()) 192 expected := "foo = [\n {\n key = value,\n key2 = value2\n },\n {\n key = value\n }\n]" 193 if actual != expected { 194 t.Fatalf("bad:\n%#v\n%#v", expected, actual) 195 } 196 } 197 198 func TestOutput_json(t *testing.T) { 199 originalState := &terraform.State{ 200 Modules: []*terraform.ModuleState{ 201 { 202 Path: []string{"root"}, 203 Outputs: map[string]*terraform.OutputState{ 204 "foo": { 205 Value: "bar", 206 Type: "string", 207 }, 208 }, 209 }, 210 }, 211 } 212 213 statePath := testStateFile(t, originalState) 214 215 ui := new(cli.MockUi) 216 c := &OutputCommand{ 217 Meta: Meta{ 218 testingOverrides: metaOverridesForProvider(testProvider()), 219 Ui: ui, 220 }, 221 } 222 223 args := []string{ 224 "-state", statePath, 225 "-json", 226 } 227 if code := c.Run(args); code != 0 { 228 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 229 } 230 231 actual := strings.TrimSpace(ui.OutputWriter.String()) 232 expected := "{\n \"foo\": {\n \"sensitive\": false,\n \"type\": \"string\",\n \"value\": \"bar\"\n }\n}" 233 if actual != expected { 234 t.Fatalf("bad:\n%#v\n%#v", expected, actual) 235 } 236 } 237 238 func TestOutput_emptyOutputsErr(t *testing.T) { 239 originalState := &terraform.State{ 240 Modules: []*terraform.ModuleState{ 241 { 242 Path: []string{"root"}, 243 Outputs: map[string]*terraform.OutputState{}, 244 }, 245 }, 246 } 247 248 statePath := testStateFile(t, originalState) 249 250 p := testProvider() 251 ui := new(cli.MockUi) 252 c := &OutputCommand{ 253 Meta: Meta{ 254 testingOverrides: metaOverridesForProvider(p), 255 Ui: ui, 256 }, 257 } 258 259 args := []string{ 260 "-state", statePath, 261 } 262 if code := c.Run(args); code != 1 { 263 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 264 } 265 } 266 267 func TestOutput_jsonEmptyOutputs(t *testing.T) { 268 originalState := &terraform.State{ 269 Modules: []*terraform.ModuleState{ 270 { 271 Path: []string{"root"}, 272 Outputs: map[string]*terraform.OutputState{}, 273 }, 274 }, 275 } 276 277 statePath := testStateFile(t, originalState) 278 279 p := testProvider() 280 ui := new(cli.MockUi) 281 c := &OutputCommand{ 282 Meta: Meta{ 283 testingOverrides: metaOverridesForProvider(p), 284 Ui: ui, 285 }, 286 } 287 288 args := []string{ 289 "-state", statePath, 290 "-json", 291 } 292 if code := c.Run(args); code != 0 { 293 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 294 } 295 296 actual := strings.TrimSpace(ui.OutputWriter.String()) 297 expected := "{}" 298 if actual != expected { 299 t.Fatalf("bad:\n%#v\n%#v", expected, actual) 300 } 301 } 302 303 func TestMissingModuleOutput(t *testing.T) { 304 originalState := &terraform.State{ 305 Modules: []*terraform.ModuleState{ 306 { 307 Path: []string{"root"}, 308 Outputs: map[string]*terraform.OutputState{ 309 "foo": { 310 Value: "bar", 311 Type: "string", 312 }, 313 }, 314 }, 315 }, 316 } 317 318 statePath := testStateFile(t, originalState) 319 320 ui := new(cli.MockUi) 321 c := &OutputCommand{ 322 Meta: Meta{ 323 testingOverrides: metaOverridesForProvider(testProvider()), 324 Ui: ui, 325 }, 326 } 327 328 args := []string{ 329 "-state", statePath, 330 "-module", "not_existing_module", 331 "blah", 332 } 333 334 if code := c.Run(args); code != 1 { 335 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 336 } 337 } 338 339 func TestOutput_badVar(t *testing.T) { 340 originalState := &terraform.State{ 341 Modules: []*terraform.ModuleState{ 342 { 343 Path: []string{"root"}, 344 Outputs: map[string]*terraform.OutputState{ 345 "foo": { 346 Value: "bar", 347 Type: "string", 348 }, 349 }, 350 }, 351 }, 352 } 353 354 statePath := testStateFile(t, originalState) 355 356 ui := new(cli.MockUi) 357 c := &OutputCommand{ 358 Meta: Meta{ 359 testingOverrides: metaOverridesForProvider(testProvider()), 360 Ui: ui, 361 }, 362 } 363 364 args := []string{ 365 "-state", statePath, 366 "bar", 367 } 368 if code := c.Run(args); code != 1 { 369 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 370 } 371 } 372 373 func TestOutput_blank(t *testing.T) { 374 originalState := &terraform.State{ 375 Modules: []*terraform.ModuleState{ 376 { 377 Path: []string{"root"}, 378 Outputs: map[string]*terraform.OutputState{ 379 "foo": { 380 Value: "bar", 381 Type: "string", 382 }, 383 "name": { 384 Value: "john-doe", 385 Type: "string", 386 }, 387 }, 388 }, 389 }, 390 } 391 392 statePath := testStateFile(t, originalState) 393 394 ui := new(cli.MockUi) 395 c := &OutputCommand{ 396 Meta: Meta{ 397 testingOverrides: metaOverridesForProvider(testProvider()), 398 Ui: ui, 399 }, 400 } 401 402 args := []string{ 403 "-state", statePath, 404 "", 405 } 406 407 if code := c.Run(args); code != 0 { 408 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 409 } 410 411 expectedOutput := "foo = bar\nname = john-doe\n" 412 output := ui.OutputWriter.String() 413 if output != expectedOutput { 414 t.Fatalf("Expected output: %#v\ngiven: %#v", expectedOutput, output) 415 } 416 } 417 418 func TestOutput_manyArgs(t *testing.T) { 419 ui := new(cli.MockUi) 420 c := &OutputCommand{ 421 Meta: Meta{ 422 testingOverrides: metaOverridesForProvider(testProvider()), 423 Ui: ui, 424 }, 425 } 426 427 args := []string{ 428 "bad", 429 "bad", 430 } 431 if code := c.Run(args); code != 1 { 432 t.Fatalf("bad: \n%s", ui.OutputWriter.String()) 433 } 434 } 435 436 func TestOutput_noArgs(t *testing.T) { 437 ui := new(cli.MockUi) 438 c := &OutputCommand{ 439 Meta: Meta{ 440 testingOverrides: metaOverridesForProvider(testProvider()), 441 Ui: ui, 442 }, 443 } 444 445 args := []string{} 446 if code := c.Run(args); code != 1 { 447 t.Fatalf("bad: \n%s", ui.OutputWriter.String()) 448 } 449 } 450 451 func TestOutput_noState(t *testing.T) { 452 originalState := &terraform.State{} 453 statePath := testStateFile(t, originalState) 454 455 ui := new(cli.MockUi) 456 c := &OutputCommand{ 457 Meta: Meta{ 458 testingOverrides: metaOverridesForProvider(testProvider()), 459 Ui: ui, 460 }, 461 } 462 463 args := []string{ 464 "-state", statePath, 465 "foo", 466 } 467 if code := c.Run(args); code != 1 { 468 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 469 } 470 } 471 472 func TestOutput_noVars(t *testing.T) { 473 originalState := &terraform.State{ 474 Modules: []*terraform.ModuleState{ 475 { 476 Path: []string{"root"}, 477 Outputs: map[string]*terraform.OutputState{}, 478 }, 479 }, 480 } 481 482 statePath := testStateFile(t, originalState) 483 484 ui := new(cli.MockUi) 485 c := &OutputCommand{ 486 Meta: Meta{ 487 testingOverrides: metaOverridesForProvider(testProvider()), 488 Ui: ui, 489 }, 490 } 491 492 args := []string{ 493 "-state", statePath, 494 "bar", 495 } 496 if code := c.Run(args); code != 1 { 497 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 498 } 499 } 500 501 func TestOutput_stateDefault(t *testing.T) { 502 originalState := &terraform.State{ 503 Modules: []*terraform.ModuleState{ 504 { 505 Path: []string{"root"}, 506 Outputs: map[string]*terraform.OutputState{ 507 "foo": { 508 Value: "bar", 509 Type: "string", 510 }, 511 }, 512 }, 513 }, 514 } 515 516 // Write the state file in a temporary directory with the 517 // default filename. 518 td := testTempDir(t) 519 statePath := filepath.Join(td, DefaultStateFilename) 520 521 f, err := os.Create(statePath) 522 if err != nil { 523 t.Fatalf("err: %s", err) 524 } 525 err = terraform.WriteState(originalState, f) 526 f.Close() 527 if err != nil { 528 t.Fatalf("err: %s", err) 529 } 530 531 // Change to that directory 532 cwd, err := os.Getwd() 533 if err != nil { 534 t.Fatalf("err: %s", err) 535 } 536 if err := os.Chdir(filepath.Dir(statePath)); err != nil { 537 t.Fatalf("err: %s", err) 538 } 539 defer os.Chdir(cwd) 540 541 ui := new(cli.MockUi) 542 c := &OutputCommand{ 543 Meta: Meta{ 544 testingOverrides: metaOverridesForProvider(testProvider()), 545 Ui: ui, 546 }, 547 } 548 549 args := []string{ 550 "foo", 551 } 552 if code := c.Run(args); code != 0 { 553 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 554 } 555 556 actual := strings.TrimSpace(ui.OutputWriter.String()) 557 if actual != "bar" { 558 t.Fatalf("bad: %#v", actual) 559 } 560 }