github.com/vic3lord/terraform@v0.8.0-rc1.0.20170626102919-16c6dd2cb372/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  `