terraform/command/refresh_test.go

990 lines
24 KiB
Go
Raw Normal View History

2014-06-27 20:09:01 +02:00
package command
import (
"bytes"
"fmt"
2014-06-27 20:09:01 +02:00
"io/ioutil"
"os"
"path/filepath"
"reflect"
2014-09-18 19:40:23 +02:00
"strings"
2014-09-21 18:42:48 +02:00
"testing"
2014-06-27 20:09:01 +02:00
"github.com/davecgh/go-spew/spew"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/mitchellh/cli"
"github.com/zclconf/go-cty/cty"
"github.com/hashicorp/terraform/addrs"
"github.com/hashicorp/terraform/configs/configschema"
"github.com/hashicorp/terraform/providers"
"github.com/hashicorp/terraform/states"
"github.com/hashicorp/terraform/states/statefile"
"github.com/hashicorp/terraform/states/statemgr"
"github.com/hashicorp/terraform/tfdiags"
2014-06-27 20:09:01 +02:00
)
2019-10-24 04:32:44 +02:00
var equateEmpty = cmpopts.EquateEmpty()
2014-06-27 20:09:01 +02:00
func TestRefresh(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2014-09-17 20:15:07 +02:00
state := testState()
statePath := testStateFile(t, state)
2014-06-27 20:09:01 +02:00
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
2014-06-27 20:09:01 +02:00
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
2014-06-27 20:09:01 +02:00
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
2014-06-27 20:09:01 +02:00
args := []string{
"-state", statePath,
2014-06-27 20:09:01 +02:00
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-06-27 20:09:01 +02:00
}
if !p.ReadResourceCalled {
t.Fatal("ReadResource should have been called")
2014-06-27 20:09:01 +02:00
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
newStateFile, err := statefile.Read(f)
2014-06-27 20:09:01 +02:00
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(newStateFile.State.String())
2014-09-18 19:40:23 +02:00
expected := strings.TrimSpace(testRefreshStr)
if actual != expected {
t.Fatalf("bad:\n\n%s", actual)
2014-06-27 20:09:01 +02:00
}
}
2014-06-27 20:12:45 +02:00
func TestRefresh_empty(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-empty"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
args := []string{}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
if p.ReadResourceCalled {
t.Fatal("ReadResource should not have been called")
}
}
func TestRefresh_lockedState(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
state := testState()
statePath := testStateFile(t, state)
unlock, err := testLockState(testDataDir, statePath)
if err != nil {
t.Fatal(err)
}
defer unlock()
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
args := []string{
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code == 0 {
t.Fatal("expected error")
}
2021-02-22 17:38:39 +01:00
got := output.Stderr()
if !strings.Contains(got, "lock") {
t.Fatal("command output does not look like a lock error:", got)
}
}
func TestRefresh_cwd(t *testing.T) {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(testFixturePath("refresh")); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
2014-09-17 20:15:07 +02:00
state := testState()
statePath := testStateFile(t, state)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
args := []string{
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
if !p.ReadResourceCalled {
t.Fatal("ReadResource should have been called")
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
newStateFile, err := statefile.Read(f)
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(newStateFile.State.String())
2014-09-18 19:40:23 +02:00
expected := strings.TrimSpace(testRefreshCwdStr)
if actual != expected {
t.Fatalf("bad:\n\n%s", actual)
}
}
func TestRefresh_defaultState(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
originalState := testState()
// Write the state file in a temporary directory with the
// default filename.
statePath := testStateFile(t, originalState)
localState := statemgr.NewFilesystem(statePath)
if err := localState.RefreshState(); err != nil {
t.Fatal(err)
}
s := localState.State()
if s == nil {
t.Fatal("empty test state")
}
// Change to that directory
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(filepath.Dir(statePath)); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
args := []string{
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
if !p.ReadResourceCalled {
t.Fatal("ReadResource should have been called")
}
newState := testStateRead(t, statePath)
actual := newState.RootModule().Resources["test_instance.foo"].Instances[addrs.NoKey].Current
expected := &states.ResourceInstanceObjectSrc{
Status: states.ObjectReady,
AttrsJSON: []byte("{\n \"ami\": null,\n \"id\": \"yes\"\n }"),
Dependencies: []addrs.ConfigResource{},
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("wrong new object\ngot: %swant: %s", spew.Sdump(actual), spew.Sdump(expected))
}
backupState := testStateRead(t, statePath+DefaultBackupExtension)
actual = backupState.RootModule().Resources["test_instance.foo"].Instances[addrs.NoKey].Current
expected = originalState.RootModule().Resources["test_instance.foo"].Instances[addrs.NoKey].Current
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("wrong new object\ngot: %swant: %s", spew.Sdump(actual), spew.Sdump(expected))
}
}
2014-06-27 20:12:45 +02:00
func TestRefresh_outPath(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
state := testState()
statePath := testStateFile(t, state)
// Output path
outf, err := ioutil.TempFile(testingDir, "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
outPath := outf.Name()
outf.Close()
os.Remove(outPath)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
args := []string{
"-state", statePath,
"-state-out", outPath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
newState := testStateRead(t, statePath)
if !reflect.DeepEqual(newState, state) {
t.Fatalf("bad: %#v", newState)
}
newState = testStateRead(t, outPath)
actual := newState.RootModule().Resources["test_instance.foo"].Instances[addrs.NoKey].Current
expected := &states.ResourceInstanceObjectSrc{
Status: states.ObjectReady,
AttrsJSON: []byte("{\n \"ami\": null,\n \"id\": \"yes\"\n }"),
Dependencies: []addrs.ConfigResource{},
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("wrong new object\ngot: %swant: %s", spew.Sdump(actual), spew.Sdump(expected))
}
if _, err := os.Stat(outPath + DefaultBackupExtension); !os.IsNotExist(err) {
if err != nil {
t.Fatalf("failed to test for backup file: %s", err)
}
t.Fatalf("backup file exists, but it should not because output file did not initially exist")
}
2014-06-27 20:12:45 +02:00
}
2014-07-18 20:37:27 +02:00
func TestRefresh_var(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-var"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2014-09-17 20:15:07 +02:00
state := testState()
2014-07-18 20:37:27 +02:00
statePath := testStateFile(t, state)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
2014-07-18 20:37:27 +02:00
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
2014-07-18 20:37:27 +02:00
},
}
p.GetProviderSchemaResponse = refreshVarFixtureSchema()
2014-07-18 20:37:27 +02:00
args := []string{
"-var", "foo=bar",
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-07-18 20:37:27 +02:00
}
if !p.ConfigureProviderCalled {
2014-07-18 20:37:27 +02:00
t.Fatal("configure should be called")
}
if got, want := p.ConfigureProviderRequest.Config.GetAttr("value"), cty.StringVal("bar"); !want.RawEquals(got) {
t.Fatalf("wrong provider configuration\ngot: %#v\nwant: %#v", got, want)
2014-07-18 20:37:27 +02:00
}
}
2014-07-18 23:00:40 +02:00
func TestRefresh_varFile(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-var"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2014-09-17 20:15:07 +02:00
state := testState()
2014-07-18 23:00:40 +02:00
statePath := testStateFile(t, state)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
2014-07-18 23:00:40 +02:00
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
2014-07-18 23:00:40 +02:00
},
}
p.GetProviderSchemaResponse = refreshVarFixtureSchema()
2014-07-18 23:00:40 +02:00
varFilePath := testTempFile(t)
if err := ioutil.WriteFile(varFilePath, []byte(refreshVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
args := []string{
"-var-file", varFilePath,
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2014-07-18 23:00:40 +02:00
}
if !p.ConfigureProviderCalled {
2014-07-18 23:00:40 +02:00
t.Fatal("configure should be called")
}
if got, want := p.ConfigureProviderRequest.Config.GetAttr("value"), cty.StringVal("bar"); !want.RawEquals(got) {
t.Fatalf("wrong provider configuration\ngot: %#v\nwant: %#v", got, want)
2014-07-18 23:00:40 +02:00
}
}
func TestRefresh_varFileDefault(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-var"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2014-09-17 20:15:07 +02:00
state := testState()
statePath := testStateFile(t, state)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshVarFixtureSchema()
varFilePath := filepath.Join(td, "terraform.tfvars")
if err := ioutil.WriteFile(varFilePath, []byte(refreshVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
args := []string{
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
if !p.ConfigureProviderCalled {
t.Fatal("configure should be called")
}
if got, want := p.ConfigureProviderRequest.Config.GetAttr("value"), cty.StringVal("bar"); !want.RawEquals(got) {
t.Fatalf("wrong provider configuration\ngot: %#v\nwant: %#v", got, want)
}
}
2015-11-23 09:32:46 +01:00
func TestRefresh_varsUnset(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-unset-var"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2015-11-23 09:32:46 +01:00
// Disable test mode so input would be asked
test = false
defer func() { test = true }()
defaultInputReader = bytes.NewBufferString("bar\n")
state := testState()
statePath := testStateFile(t, state)
p := testProvider()
ui := new(cli.MockUi)
2021-02-22 17:38:39 +01:00
view, done := testView(t)
2015-11-23 09:32:46 +01:00
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
Ui: ui,
View: view,
2015-11-23 09:32:46 +01:00
},
}
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
"ami": {Type: cty.String, Optional: true},
},
},
},
},
}
2015-11-23 09:32:46 +01:00
args := []string{
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
2015-11-23 09:32:46 +01:00
}
}
2014-07-28 04:58:12 +02:00
func TestRefresh_backup(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
state := testState()
statePath := testStateFile(t, state)
// Output path
outf, err := ioutil.TempFile(testingDir, "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
outPath := outf.Name()
defer outf.Close()
// Need to put some state content in the output file so that there's
// something to back up.
err = statefile.Write(statefile.New(state, "baz", 0), outf)
if err != nil {
t.Fatalf("error writing initial output state file %s", err)
}
// Backup path
backupf, err := ioutil.TempFile(testingDir, "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
backupPath := backupf.Name()
backupf.Close()
os.Remove(backupPath)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("changed"),
}),
}
args := []string{
"-state", statePath,
"-state-out", outPath,
"-backup", backupPath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
newState := testStateRead(t, statePath)
if !cmp.Equal(newState, state, cmpopts.EquateEmpty()) {
t.Fatalf("got:\n%s\nexpected:\n%s\n", newState, state)
}
newState = testStateRead(t, outPath)
actual := newState.RootModule().Resources["test_instance.foo"].Instances[addrs.NoKey].Current
expected := &states.ResourceInstanceObjectSrc{
Status: states.ObjectReady,
AttrsJSON: []byte("{\n \"ami\": null,\n \"id\": \"changed\"\n }"),
Dependencies: []addrs.ConfigResource{},
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("wrong new object\ngot: %swant: %s", spew.Sdump(actual), spew.Sdump(expected))
}
backupState := testStateRead(t, backupPath)
actualStr := strings.TrimSpace(backupState.String())
expectedStr := strings.TrimSpace(state.String())
if actualStr != expectedStr {
t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr)
}
2014-07-28 04:58:12 +02:00
}
2014-07-28 05:38:41 +02:00
func TestRefresh_disableBackup(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
state := testState()
statePath := testStateFile(t, state)
// Output path
outf, err := ioutil.TempFile(testingDir, "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
outPath := outf.Name()
outf.Close()
os.Remove(outPath)
p := testProvider()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.ReadResourceFn = nil
2021-01-12 22:13:10 +01:00
p.ReadResourceResponse = &providers.ReadResourceResponse{
NewState: cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("yes"),
}),
}
args := []string{
"-state", statePath,
"-state-out", outPath,
"-backup", "-",
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
newState := testStateRead(t, statePath)
2019-10-24 04:32:44 +02:00
if !cmp.Equal(state, newState, equateEmpty) {
spew.Config.DisableMethods = true
fmt.Println(cmp.Diff(state, newState, equateEmpty))
t.Fatalf("bad: %s", newState)
}
newState = testStateRead(t, outPath)
actual := newState.RootModule().Resources["test_instance.foo"].Instances[addrs.NoKey].Current
expected := &states.ResourceInstanceObjectSrc{
Status: states.ObjectReady,
AttrsJSON: []byte("{\n \"ami\": null,\n \"id\": \"yes\"\n }"),
Dependencies: []addrs.ConfigResource{},
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("wrong new object\ngot: %swant: %s", spew.Sdump(actual), spew.Sdump(expected))
}
// Ensure there is no backup
_, err = os.Stat(outPath + DefaultBackupExtension)
if err == nil || !os.IsNotExist(err) {
t.Fatalf("backup should not exist")
}
_, err = os.Stat("-")
if err == nil || !os.IsNotExist(err) {
t.Fatalf("backup should not exist")
}
2014-07-28 05:38:41 +02:00
}
func TestRefresh_displaysOutputs(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-output"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
state := testState()
statePath := testStateFile(t, state)
p := testProvider()
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
"ami": {Type: cty.String, Optional: true},
},
},
},
},
}
args := []string{
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
// Test that outputs were displayed
outputValue := "foo.example.com"
2021-02-22 17:38:39 +01:00
actual := output.Stdout()
if !strings.Contains(actual, outputValue) {
t.Fatalf("Expected:\n%s\n\nTo include: %q", actual, outputValue)
}
}
// Config with multiple resources, targeting refresh of a subset
func TestRefresh_targeted(t *testing.T) {
td := tempDir(t)
testCopyDir(t, testFixturePath("refresh-targeted"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
state := testState()
statePath := testStateFile(t, state)
p := testProvider()
p.GetProviderSchemaResponse = &providers.GetProviderSchemaResponse{
ResourceTypes: map[string]providers.Schema{
"test_instance": {
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Computed: true},
},
},
},
},
}
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
}
}
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
args := []string{
"-target", "test_instance.foo",
"-state", statePath,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
2021-02-22 17:38:39 +01:00
got := output.Stdout()
if want := "test_instance.foo: Refreshing"; !strings.Contains(got, want) {
t.Fatalf("expected output to contain %q, got:\n%s", want, got)
}
if doNotWant := "test_instance.bar: Refreshing"; strings.Contains(got, doNotWant) {
t.Fatalf("expected output not to contain %q, got:\n%s", doNotWant, got)
}
}
// Diagnostics for invalid -target flags
func TestRefresh_targetFlagsDiags(t *testing.T) {
testCases := map[string]string{
"test_instance.": "Dot must be followed by attribute name.",
"test_instance": "Resource specification must include a resource type and name.",
}
for target, wantDiag := range testCases {
t.Run(target, func(t *testing.T) {
td := testTempDir(t)
defer os.RemoveAll(td)
defer testChdir(t, td)()
2021-02-22 17:38:39 +01:00
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
View: view,
},
}
args := []string{
"-target", target,
}
2021-02-22 17:38:39 +01:00
code := c.Run(args)
output := done(t)
if code != 1 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
2021-02-22 17:38:39 +01:00
got := output.Stderr()
if !strings.Contains(got, target) {
t.Fatalf("bad error output, want %q, got:\n%s", target, got)
}
if !strings.Contains(got, wantDiag) {
t.Fatalf("bad error output, want %q, got:\n%s", wantDiag, got)
}
})
}
}
func TestRefresh_warnings(t *testing.T) {
// Create a temporary working directory that is empty
td := tempDir(t)
testCopyDir(t, testFixturePath("apply"), td)
defer os.RemoveAll(td)
defer testChdir(t, td)()
p := testProvider()
p.GetProviderSchemaResponse = refreshFixtureSchema()
p.PlanResourceChangeFn = func(req providers.PlanResourceChangeRequest) providers.PlanResourceChangeResponse {
return providers.PlanResourceChangeResponse{
PlannedState: req.ProposedNewState,
Diagnostics: tfdiags.Diagnostics{
tfdiags.SimpleWarning("warning 1"),
tfdiags.SimpleWarning("warning 2"),
},
}
}
t.Run("full warnings", func(t *testing.T) {
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
code := c.Run([]string{})
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
wantWarnings := []string{
"warning 1",
"warning 2",
}
for _, want := range wantWarnings {
if !strings.Contains(output.Stdout(), want) {
t.Errorf("missing warning %s", want)
}
}
})
t.Run("compact warnings", func(t *testing.T) {
view, done := testView(t)
c := &RefreshCommand{
Meta: Meta{
testingOverrides: metaOverridesForProvider(p),
View: view,
},
}
code := c.Run([]string{"-compact-warnings"})
output := done(t)
if code != 0 {
t.Fatalf("bad: %d\n\n%s", code, output.Stderr())
}
// the output should contain 2 warnings and a message about -compact-warnings
wantWarnings := []string{
"warning 1",
"warning 2",
"To see the full warning notes, run Terraform without -compact-warnings.",
}
for _, want := range wantWarnings {
if !strings.Contains(output.Stdout(), want) {
t.Errorf("missing warning %s", want)
}
}
})
}
// configuration in testdata/refresh . This schema should be
// assigned to a mock provider named "test".
func refreshFixtureSchema() *providers.GetProviderSchemaResponse {
return &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
"ami": {Type: cty.String, Optional: true},
},
},
},
},
}
}
// refreshVarFixtureSchema returns a schema suitable for processing the
// configuration in testdata/refresh-var . This schema should be
// assigned to a mock provider named "test".
func refreshVarFixtureSchema() *providers.GetProviderSchemaResponse {
return &providers.GetProviderSchemaResponse{
2021-01-12 22:13:10 +01:00
Provider: providers.Schema{
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"value": {Type: cty.String, Optional: true},
},
},
},
2021-01-12 22:13:10 +01:00
ResourceTypes: map[string]providers.Schema{
"test_instance": {
2021-01-12 22:13:10 +01:00
Block: &configschema.Block{
Attributes: map[string]*configschema.Attribute{
"id": {Type: cty.String, Optional: true, Computed: true},
},
},
},
},
}
}
2014-07-18 23:00:40 +02:00
const refreshVarFile = `
foo = "bar"
`
2014-09-18 19:40:23 +02:00
const testRefreshStr = `
test_instance.foo:
ID = yes
provider = provider["registry.terraform.io/hashicorp/test"]
2014-09-18 19:40:23 +02:00
`
const testRefreshCwdStr = `
test_instance.foo:
ID = yes
provider = provider["registry.terraform.io/hashicorp/test"]
2014-09-18 19:40:23 +02:00
`