github.com/kevholditch/terraform@v0.9.7-0.20170613192930-9706042ddd51/command/import_test.go (about) 1 package command 2 3 import ( 4 "fmt" 5 "strings" 6 "testing" 7 8 "github.com/hashicorp/terraform/terraform" 9 "github.com/mitchellh/cli" 10 ) 11 12 func TestImport(t *testing.T) { 13 defer testChdir(t, testFixturePath("import-provider-implicit"))() 14 15 statePath := testTempFile(t) 16 17 p := testProvider() 18 ui := new(cli.MockUi) 19 c := &ImportCommand{ 20 Meta: Meta{ 21 testingOverrides: metaOverridesForProvider(p), 22 Ui: ui, 23 }, 24 } 25 26 p.ImportStateFn = nil 27 p.ImportStateReturn = []*terraform.InstanceState{ 28 &terraform.InstanceState{ 29 ID: "yay", 30 Ephemeral: terraform.EphemeralState{ 31 Type: "test_instance", 32 }, 33 }, 34 } 35 36 args := []string{ 37 "-state", statePath, 38 "test_instance.foo", 39 "bar", 40 } 41 if code := c.Run(args); code != 0 { 42 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 43 } 44 45 if !p.ImportStateCalled { 46 t.Fatal("ImportState should be called") 47 } 48 49 testStateOutput(t, statePath, testImportStr) 50 } 51 52 func TestImport_providerConfig(t *testing.T) { 53 defer testChdir(t, testFixturePath("import-provider"))() 54 55 statePath := testTempFile(t) 56 57 p := testProvider() 58 ui := new(cli.MockUi) 59 c := &ImportCommand{ 60 Meta: Meta{ 61 testingOverrides: metaOverridesForProvider(p), 62 Ui: ui, 63 }, 64 } 65 66 p.ImportStateFn = nil 67 p.ImportStateReturn = []*terraform.InstanceState{ 68 &terraform.InstanceState{ 69 ID: "yay", 70 Ephemeral: terraform.EphemeralState{ 71 Type: "test_instance", 72 }, 73 }, 74 } 75 76 configured := false 77 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 78 configured = true 79 80 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 81 return fmt.Errorf("bad value: %#v", v) 82 } 83 84 return nil 85 } 86 87 args := []string{ 88 "-state", statePath, 89 "test_instance.foo", 90 "bar", 91 } 92 if code := c.Run(args); code != 0 { 93 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 94 } 95 96 // Verify that we were called 97 if !configured { 98 t.Fatal("Configure should be called") 99 } 100 101 if !p.ImportStateCalled { 102 t.Fatal("ImportState should be called") 103 } 104 105 testStateOutput(t, statePath, testImportStr) 106 } 107 108 func TestImport_providerConfigWithVar(t *testing.T) { 109 defer testChdir(t, testFixturePath("import-provider-var"))() 110 111 statePath := testTempFile(t) 112 113 p := testProvider() 114 ui := new(cli.MockUi) 115 c := &ImportCommand{ 116 Meta: Meta{ 117 testingOverrides: metaOverridesForProvider(p), 118 Ui: ui, 119 }, 120 } 121 122 p.ImportStateFn = nil 123 p.ImportStateReturn = []*terraform.InstanceState{ 124 &terraform.InstanceState{ 125 ID: "yay", 126 Ephemeral: terraform.EphemeralState{ 127 Type: "test_instance", 128 }, 129 }, 130 } 131 132 configured := false 133 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 134 configured = true 135 136 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 137 return fmt.Errorf("bad value: %#v", v) 138 } 139 140 return nil 141 } 142 143 args := []string{ 144 "-state", statePath, 145 "-var", "foo=bar", 146 "test_instance.foo", 147 "bar", 148 } 149 if code := c.Run(args); code != 0 { 150 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 151 } 152 153 // Verify that we were called 154 if !configured { 155 t.Fatal("Configure should be called") 156 } 157 158 if !p.ImportStateCalled { 159 t.Fatal("ImportState should be called") 160 } 161 162 testStateOutput(t, statePath, testImportStr) 163 } 164 165 func TestImport_providerConfigWithVarDefault(t *testing.T) { 166 defer testChdir(t, testFixturePath("import-provider-var-default"))() 167 168 statePath := testTempFile(t) 169 170 p := testProvider() 171 ui := new(cli.MockUi) 172 c := &ImportCommand{ 173 Meta: Meta{ 174 testingOverrides: metaOverridesForProvider(p), 175 Ui: ui, 176 }, 177 } 178 179 p.ImportStateFn = nil 180 p.ImportStateReturn = []*terraform.InstanceState{ 181 &terraform.InstanceState{ 182 ID: "yay", 183 Ephemeral: terraform.EphemeralState{ 184 Type: "test_instance", 185 }, 186 }, 187 } 188 189 configured := false 190 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 191 configured = true 192 193 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 194 return fmt.Errorf("bad value: %#v", v) 195 } 196 197 return nil 198 } 199 200 args := []string{ 201 "-state", statePath, 202 "test_instance.foo", 203 "bar", 204 } 205 if code := c.Run(args); code != 0 { 206 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 207 } 208 209 // Verify that we were called 210 if !configured { 211 t.Fatal("Configure should be called") 212 } 213 214 if !p.ImportStateCalled { 215 t.Fatal("ImportState should be called") 216 } 217 218 testStateOutput(t, statePath, testImportStr) 219 } 220 221 func TestImport_providerConfigWithVarFile(t *testing.T) { 222 defer testChdir(t, testFixturePath("import-provider-var-file"))() 223 224 statePath := testTempFile(t) 225 226 p := testProvider() 227 ui := new(cli.MockUi) 228 c := &ImportCommand{ 229 Meta: Meta{ 230 testingOverrides: metaOverridesForProvider(p), 231 Ui: ui, 232 }, 233 } 234 235 p.ImportStateFn = nil 236 p.ImportStateReturn = []*terraform.InstanceState{ 237 &terraform.InstanceState{ 238 ID: "yay", 239 Ephemeral: terraform.EphemeralState{ 240 Type: "test_instance", 241 }, 242 }, 243 } 244 245 configured := false 246 p.ConfigureFn = func(c *terraform.ResourceConfig) error { 247 configured = true 248 249 if v, ok := c.Get("foo"); !ok || v.(string) != "bar" { 250 return fmt.Errorf("bad value: %#v", v) 251 } 252 253 return nil 254 } 255 256 args := []string{ 257 "-state", statePath, 258 "-var-file", "blah.tfvars", 259 "test_instance.foo", 260 "bar", 261 } 262 if code := c.Run(args); code != 0 { 263 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 264 } 265 266 // Verify that we were called 267 if !configured { 268 t.Fatal("Configure should be called") 269 } 270 271 if !p.ImportStateCalled { 272 t.Fatal("ImportState should be called") 273 } 274 275 testStateOutput(t, statePath, testImportStr) 276 } 277 278 func TestImport_customProvider(t *testing.T) { 279 defer testChdir(t, testFixturePath("import-provider-aliased"))() 280 281 statePath := testTempFile(t) 282 283 p := testProvider() 284 ui := new(cli.MockUi) 285 c := &ImportCommand{ 286 Meta: Meta{ 287 testingOverrides: metaOverridesForProvider(p), 288 Ui: ui, 289 }, 290 } 291 292 p.ImportStateFn = nil 293 p.ImportStateReturn = []*terraform.InstanceState{ 294 &terraform.InstanceState{ 295 ID: "yay", 296 Ephemeral: terraform.EphemeralState{ 297 Type: "test_instance", 298 }, 299 }, 300 } 301 302 args := []string{ 303 "-provider", "test.alias", 304 "-state", statePath, 305 "test_instance.foo", 306 "bar", 307 } 308 if code := c.Run(args); code != 0 { 309 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 310 } 311 312 if !p.ImportStateCalled { 313 t.Fatal("ImportState should be called") 314 } 315 316 testStateOutput(t, statePath, testImportCustomProviderStr) 317 } 318 319 func TestImport_missingResourceConfig(t *testing.T) { 320 defer testChdir(t, testFixturePath("import-missing-resource-config"))() 321 322 statePath := testTempFile(t) 323 324 p := testProvider() 325 ui := new(cli.MockUi) 326 c := &ImportCommand{ 327 Meta: Meta{ 328 testingOverrides: metaOverridesForProvider(p), 329 Ui: ui, 330 }, 331 } 332 333 args := []string{ 334 "-state", statePath, 335 "test_instance.foo", 336 "bar", 337 } 338 code := c.Run(args) 339 if code != 1 { 340 t.Fatalf("import succeeded; expected failure") 341 } 342 343 msg := ui.ErrorWriter.String() 344 if want := `resource address "test_instance.foo" does not exist`; !strings.Contains(msg, want) { 345 t.Errorf("incorrect message\nwant substring: %s\ngot:\n%s", want, msg) 346 } 347 } 348 349 func TestImport_missingModuleConfig(t *testing.T) { 350 defer testChdir(t, testFixturePath("import-missing-resource-config"))() 351 352 statePath := testTempFile(t) 353 354 p := testProvider() 355 ui := new(cli.MockUi) 356 c := &ImportCommand{ 357 Meta: Meta{ 358 testingOverrides: metaOverridesForProvider(p), 359 Ui: ui, 360 }, 361 } 362 363 args := []string{ 364 "-state", statePath, 365 "module.baz.test_instance.foo", 366 "bar", 367 } 368 code := c.Run(args) 369 if code != 1 { 370 t.Fatalf("import succeeded; expected failure") 371 } 372 373 msg := ui.ErrorWriter.String() 374 if want := `module.baz does not exist in the configuration`; !strings.Contains(msg, want) { 375 t.Errorf("incorrect message\nwant substring: %s\ngot:\n%s", want, msg) 376 } 377 } 378 379 func TestImport_dataResource(t *testing.T) { 380 defer testChdir(t, testFixturePath("import-missing-resource-config"))() 381 382 statePath := testTempFile(t) 383 384 p := testProvider() 385 ui := new(cli.MockUi) 386 c := &ImportCommand{ 387 Meta: Meta{ 388 testingOverrides: metaOverridesForProvider(p), 389 Ui: ui, 390 }, 391 } 392 393 args := []string{ 394 "-state", statePath, 395 "data.test_data_source.foo", 396 "bar", 397 } 398 code := c.Run(args) 399 if code != 1 { 400 t.Fatalf("import succeeded; expected failure") 401 } 402 403 msg := ui.ErrorWriter.String() 404 if want := `resource address must refer to a managed resource`; !strings.Contains(msg, want) { 405 t.Errorf("incorrect message\nwant substring: %s\ngot:\n%s", want, msg) 406 } 407 } 408 409 func TestImport_invalidResourceAddr(t *testing.T) { 410 defer testChdir(t, testFixturePath("import-missing-resource-config"))() 411 412 statePath := testTempFile(t) 413 414 p := testProvider() 415 ui := new(cli.MockUi) 416 c := &ImportCommand{ 417 Meta: Meta{ 418 testingOverrides: metaOverridesForProvider(p), 419 Ui: ui, 420 }, 421 } 422 423 args := []string{ 424 "-state", statePath, 425 "bananas", 426 "bar", 427 } 428 code := c.Run(args) 429 if code != 1 { 430 t.Fatalf("import succeeded; expected failure") 431 } 432 433 msg := ui.ErrorWriter.String() 434 if want := `invalid resource address "bananas"`; !strings.Contains(msg, want) { 435 t.Errorf("incorrect message\nwant substring: %s\ngot:\n%s", want, msg) 436 } 437 } 438 439 func TestImport_targetIsModule(t *testing.T) { 440 defer testChdir(t, testFixturePath("import-missing-resource-config"))() 441 442 statePath := testTempFile(t) 443 444 p := testProvider() 445 ui := new(cli.MockUi) 446 c := &ImportCommand{ 447 Meta: Meta{ 448 testingOverrides: metaOverridesForProvider(p), 449 Ui: ui, 450 }, 451 } 452 453 args := []string{ 454 "-state", statePath, 455 "module.foo", 456 "bar", 457 } 458 code := c.Run(args) 459 if code != 1 { 460 t.Fatalf("import succeeded; expected failure") 461 } 462 463 msg := ui.ErrorWriter.String() 464 if want := `resource address must include a full resource spec`; !strings.Contains(msg, want) { 465 t.Errorf("incorrect message\nwant substring: %s\ngot:\n%s", want, msg) 466 } 467 } 468 469 const testImportStr = ` 470 test_instance.foo: 471 ID = yay 472 provider = test 473 ` 474 475 const testImportCustomProviderStr = ` 476 test_instance.foo: 477 ID = yay 478 provider = test.alias 479 `