github.com/ben-turner/terraform@v0.11.8-0.20180503104400-0cc9e050ecd4/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 TestMissingModuleOutput(t *testing.T) { 239 originalState := &terraform.State{ 240 Modules: []*terraform.ModuleState{ 241 { 242 Path: []string{"root"}, 243 Outputs: map[string]*terraform.OutputState{ 244 "foo": { 245 Value: "bar", 246 Type: "string", 247 }, 248 }, 249 }, 250 }, 251 } 252 253 statePath := testStateFile(t, originalState) 254 255 ui := new(cli.MockUi) 256 c := &OutputCommand{ 257 Meta: Meta{ 258 testingOverrides: metaOverridesForProvider(testProvider()), 259 Ui: ui, 260 }, 261 } 262 263 args := []string{ 264 "-state", statePath, 265 "-module", "not_existing_module", 266 "blah", 267 } 268 269 if code := c.Run(args); code != 1 { 270 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 271 } 272 } 273 274 func TestOutput_badVar(t *testing.T) { 275 originalState := &terraform.State{ 276 Modules: []*terraform.ModuleState{ 277 { 278 Path: []string{"root"}, 279 Outputs: map[string]*terraform.OutputState{ 280 "foo": { 281 Value: "bar", 282 Type: "string", 283 }, 284 }, 285 }, 286 }, 287 } 288 289 statePath := testStateFile(t, originalState) 290 291 ui := new(cli.MockUi) 292 c := &OutputCommand{ 293 Meta: Meta{ 294 testingOverrides: metaOverridesForProvider(testProvider()), 295 Ui: ui, 296 }, 297 } 298 299 args := []string{ 300 "-state", statePath, 301 "bar", 302 } 303 if code := c.Run(args); code != 1 { 304 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 305 } 306 } 307 308 func TestOutput_blank(t *testing.T) { 309 originalState := &terraform.State{ 310 Modules: []*terraform.ModuleState{ 311 { 312 Path: []string{"root"}, 313 Outputs: map[string]*terraform.OutputState{ 314 "foo": { 315 Value: "bar", 316 Type: "string", 317 }, 318 "name": { 319 Value: "john-doe", 320 Type: "string", 321 }, 322 }, 323 }, 324 }, 325 } 326 327 statePath := testStateFile(t, originalState) 328 329 ui := new(cli.MockUi) 330 c := &OutputCommand{ 331 Meta: Meta{ 332 testingOverrides: metaOverridesForProvider(testProvider()), 333 Ui: ui, 334 }, 335 } 336 337 args := []string{ 338 "-state", statePath, 339 "", 340 } 341 342 if code := c.Run(args); code != 0 { 343 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 344 } 345 346 expectedOutput := "foo = bar\nname = john-doe\n" 347 output := ui.OutputWriter.String() 348 if output != expectedOutput { 349 t.Fatalf("Expected output: %#v\ngiven: %#v", expectedOutput, output) 350 } 351 } 352 353 func TestOutput_manyArgs(t *testing.T) { 354 ui := new(cli.MockUi) 355 c := &OutputCommand{ 356 Meta: Meta{ 357 testingOverrides: metaOverridesForProvider(testProvider()), 358 Ui: ui, 359 }, 360 } 361 362 args := []string{ 363 "bad", 364 "bad", 365 } 366 if code := c.Run(args); code != 1 { 367 t.Fatalf("bad: \n%s", ui.OutputWriter.String()) 368 } 369 } 370 371 func TestOutput_noArgs(t *testing.T) { 372 ui := new(cli.MockUi) 373 c := &OutputCommand{ 374 Meta: Meta{ 375 testingOverrides: metaOverridesForProvider(testProvider()), 376 Ui: ui, 377 }, 378 } 379 380 args := []string{} 381 if code := c.Run(args); code != 1 { 382 t.Fatalf("bad: \n%s", ui.OutputWriter.String()) 383 } 384 } 385 386 func TestOutput_noState(t *testing.T) { 387 originalState := &terraform.State{} 388 statePath := testStateFile(t, originalState) 389 390 ui := new(cli.MockUi) 391 c := &OutputCommand{ 392 Meta: Meta{ 393 testingOverrides: metaOverridesForProvider(testProvider()), 394 Ui: ui, 395 }, 396 } 397 398 args := []string{ 399 "-state", statePath, 400 "foo", 401 } 402 if code := c.Run(args); code != 1 { 403 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 404 } 405 } 406 407 func TestOutput_noVars(t *testing.T) { 408 originalState := &terraform.State{ 409 Modules: []*terraform.ModuleState{ 410 { 411 Path: []string{"root"}, 412 Outputs: map[string]*terraform.OutputState{}, 413 }, 414 }, 415 } 416 417 statePath := testStateFile(t, originalState) 418 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 "-state", statePath, 429 "bar", 430 } 431 if code := c.Run(args); code != 1 { 432 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 433 } 434 } 435 436 func TestOutput_stateDefault(t *testing.T) { 437 originalState := &terraform.State{ 438 Modules: []*terraform.ModuleState{ 439 { 440 Path: []string{"root"}, 441 Outputs: map[string]*terraform.OutputState{ 442 "foo": { 443 Value: "bar", 444 Type: "string", 445 }, 446 }, 447 }, 448 }, 449 } 450 451 // Write the state file in a temporary directory with the 452 // default filename. 453 td := testTempDir(t) 454 statePath := filepath.Join(td, DefaultStateFilename) 455 456 f, err := os.Create(statePath) 457 if err != nil { 458 t.Fatalf("err: %s", err) 459 } 460 err = terraform.WriteState(originalState, f) 461 f.Close() 462 if err != nil { 463 t.Fatalf("err: %s", err) 464 } 465 466 // Change to that directory 467 cwd, err := os.Getwd() 468 if err != nil { 469 t.Fatalf("err: %s", err) 470 } 471 if err := os.Chdir(filepath.Dir(statePath)); err != nil { 472 t.Fatalf("err: %s", err) 473 } 474 defer os.Chdir(cwd) 475 476 ui := new(cli.MockUi) 477 c := &OutputCommand{ 478 Meta: Meta{ 479 testingOverrides: metaOverridesForProvider(testProvider()), 480 Ui: ui, 481 }, 482 } 483 484 args := []string{ 485 "foo", 486 } 487 if code := c.Run(args); code != 0 { 488 t.Fatalf("bad: \n%s", ui.ErrorWriter.String()) 489 } 490 491 actual := strings.TrimSpace(ui.OutputWriter.String()) 492 if actual != "bar" { 493 t.Fatalf("bad: %#v", actual) 494 } 495 }