terraform/command/apply_test.go

964 lines
19 KiB
Go
Raw Normal View History

2014-06-19 06:36:44 +02:00
package command
import (
"fmt"
"io/ioutil"
2014-06-19 06:36:44 +02:00
"os"
"path/filepath"
2014-06-19 21:12:24 +02:00
"reflect"
2014-09-18 19:40:23 +02:00
"strings"
"sync"
2014-06-19 06:36:44 +02:00
"testing"
2014-07-03 02:08:58 +02:00
"time"
2014-06-19 06:36:44 +02:00
"github.com/hashicorp/terraform/terraform"
"github.com/mitchellh/cli"
)
func TestApply(t *testing.T) {
statePath := testTempFile(t)
2014-06-19 06:36:44 +02:00
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
2014-06-19 06:36:44 +02:00
}
args := []string{
"-state", statePath,
2014-06-19 06:36:44 +02:00
testFixturePath("apply"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
}
func TestApply_configInvalid(t *testing.T) {
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
"-state", testTempFile(t),
testFixturePath("apply-config-invalid"),
}
if code := c.Run(args); code != 1 {
t.Fatalf("bad: \n%s", ui.OutputWriter.String())
}
}
func TestApply_defaultState(t *testing.T) {
td, err := ioutil.TempDir("", "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
statePath := filepath.Join(td, DefaultStateFilename)
// Change to the temporary 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()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
testFixturePath("apply"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
}
func TestApply_error(t *testing.T) {
statePath := testTempFile(t)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
var lock sync.Mutex
errored := false
p.ApplyFn = func(
2014-09-17 20:15:07 +02:00
info *terraform.InstanceInfo,
s *terraform.InstanceState,
2014-09-18 01:33:24 +02:00
d *terraform.InstanceDiff) (*terraform.InstanceState, error) {
lock.Lock()
defer lock.Unlock()
if !errored {
errored = true
return nil, fmt.Errorf("error")
}
2014-09-17 20:15:07 +02:00
return &terraform.InstanceState{ID: "foo"}, nil
}
p.DiffFn = func(
2014-09-17 20:15:07 +02:00
*terraform.InstanceInfo,
*terraform.InstanceState,
2014-09-18 01:33:24 +02:00
*terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
return &terraform.InstanceDiff{
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}, nil
}
args := []string{
"-state", statePath,
testFixturePath("apply-error"),
}
if code := c.Run(args); code != 1 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
2014-09-17 20:15:07 +02:00
if len(state.RootModule().Resources) == 0 {
t.Fatal("no resources in state")
}
}
func TestApply_noArgs(t *testing.T) {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(testFixturePath("plan")); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
statePath := testTempFile(t)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
"-state", statePath,
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
}
func TestApply_plan(t *testing.T) {
2014-07-03 20:46:40 +02:00
planPath := testPlanFile(t, &terraform.Plan{
2014-09-25 00:48:46 +02:00
Module: testModule(t, "apply"),
2014-07-03 20:46:40 +02:00
})
statePath := testTempFile(t)
2014-06-19 06:36:44 +02:00
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
2014-06-19 06:36:44 +02:00
}
args := []string{
"-state", statePath,
planPath,
2014-06-19 06:36:44 +02:00
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
}
func TestApply_planWithVarFile(t *testing.T) {
varFileDir := testTempDir(t)
varFilePath := filepath.Join(varFileDir, "terraform.tfvars")
if err := ioutil.WriteFile(varFilePath, []byte(applyVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
planPath := testPlanFile(t, &terraform.Plan{
2014-09-25 00:48:46 +02:00
Module: testModule(t, "apply"),
})
statePath := testTempFile(t)
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(varFileDir); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
"-state", statePath,
planPath,
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
2014-06-19 06:36:44 +02:00
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
2014-06-19 21:12:24 +02:00
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
2014-06-19 21:12:24 +02:00
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
}
func TestApply_planVars(t *testing.T) {
planPath := testPlanFile(t, &terraform.Plan{
2014-09-25 00:48:46 +02:00
Module: testModule(t, "apply"),
})
statePath := testTempFile(t)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
"-state", statePath,
"-var", "foo=bar",
planPath,
}
if code := c.Run(args); code == 0 {
t.Fatal("should've failed")
}
}
2014-07-27 02:50:13 +02:00
func TestApply_refresh(t *testing.T) {
originalState := &terraform.State{
2014-09-17 20:15:07 +02:00
Modules: []*terraform.ModuleState{
&terraform.ModuleState{
Path: []string{"root"},
Resources: map[string]*terraform.ResourceState{
"test_instance.foo": &terraform.ResourceState{
Type: "test_instance",
Primary: &terraform.InstanceState{
ID: "bar",
},
},
},
2014-07-27 02:50:13 +02:00
},
},
}
statePath := testStateFile(t, originalState)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
"-state", statePath,
testFixturePath("apply"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if !p.RefreshCalled {
t.Fatal("should call refresh")
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
2014-07-28 05:38:41 +02:00
// Should have a backup file
f, err = os.Open(statePath + DefaultBackupExtention)
if err != nil {
t.Fatalf("err: %s", err)
}
backupState, err := terraform.ReadState(f)
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
2014-09-19 02:16:09 +02:00
actualStr := strings.TrimSpace(backupState.String())
expectedStr := strings.TrimSpace(originalState.String())
if actualStr != expectedStr {
t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr)
2014-07-28 05:38:41 +02:00
}
2014-07-27 02:50:13 +02:00
}
2014-07-03 02:01:02 +02:00
func TestApply_shutdown(t *testing.T) {
stopped := false
stopCh := make(chan struct{})
stopReplyCh := make(chan struct{})
statePath := testTempFile(t)
p := testProvider()
shutdownCh := make(chan struct{})
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
ShutdownCh: shutdownCh,
2014-07-03 02:01:02 +02:00
}
p.DiffFn = func(
2014-09-17 20:15:07 +02:00
*terraform.InstanceInfo,
*terraform.InstanceState,
2014-09-18 01:33:24 +02:00
*terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
return &terraform.InstanceDiff{
2014-07-03 02:01:02 +02:00
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}, nil
}
p.ApplyFn = func(
2014-09-17 20:15:07 +02:00
*terraform.InstanceInfo,
*terraform.InstanceState,
2014-09-18 01:33:24 +02:00
*terraform.InstanceDiff) (*terraform.InstanceState, error) {
2014-07-03 02:01:02 +02:00
if !stopped {
stopped = true
close(stopCh)
<-stopReplyCh
}
2014-09-17 20:15:07 +02:00
return &terraform.InstanceState{
2014-07-03 02:01:02 +02:00
ID: "foo",
Attributes: map[string]string{
"ami": "2",
},
}, nil
}
go func() {
<-stopCh
shutdownCh <- struct{}{}
2014-07-03 02:08:58 +02:00
// This is really dirty, but we have no other way to assure that
// tf.Stop() has been called. This doesn't assure it either, but
// it makes it much more certain.
time.Sleep(50 * time.Millisecond)
2014-07-03 02:01:02 +02:00
close(stopReplyCh)
}()
args := []string{
"-state", statePath,
2014-07-03 02:01:02 +02:00
testFixturePath("apply-shutdown"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
2014-09-17 20:15:07 +02:00
if len(state.RootModule().Resources) != 1 {
t.Fatalf("bad: %d", len(state.RootModule().Resources))
2014-07-03 02:01:02 +02:00
}
}
func TestApply_state(t *testing.T) {
2014-06-19 21:12:24 +02:00
originalState := &terraform.State{
2014-09-17 20:15:07 +02:00
Modules: []*terraform.ModuleState{
&terraform.ModuleState{
Path: []string{"root"},
Resources: map[string]*terraform.ResourceState{
"test_instance.foo": &terraform.ResourceState{
Type: "test_instance",
Primary: &terraform.InstanceState{
ID: "bar",
},
},
},
2014-06-19 21:12:24 +02:00
},
},
}
statePath := testStateFile(t, originalState)
2014-06-19 21:12:24 +02:00
p := testProvider()
2014-09-18 01:33:24 +02:00
p.DiffReturn = &terraform.InstanceDiff{
2014-07-01 05:49:49 +02:00
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}
2014-06-19 21:12:24 +02:00
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
2014-06-19 21:12:24 +02:00
}
// Run the apply command pointing to our existing state
args := []string{
"-state", statePath,
2014-06-19 21:12:24 +02:00
testFixturePath("apply"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
// Verify that the provider was called with the existing state
2014-09-18 19:40:23 +02:00
actual := strings.TrimSpace(p.DiffState.String())
expected := strings.TrimSpace(testApplyStateDiffStr)
if actual != expected {
t.Fatalf("bad:\n\n%s", actual)
}
2014-09-18 19:40:23 +02:00
actual = strings.TrimSpace(p.ApplyState.String())
expected = strings.TrimSpace(testApplyStateStr)
if actual != expected {
t.Fatalf("bad:\n\n%s", actual)
2014-06-19 21:12:24 +02:00
}
// Verify a new state exists
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
2014-07-28 05:38:41 +02:00
// Should have a backup file
f, err = os.Open(statePath + DefaultBackupExtention)
if err != nil {
t.Fatalf("err: %s", err)
}
backupState, err := terraform.ReadState(f)
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
// nil out the ConnInfo since that should not be restored
2014-09-17 20:15:07 +02:00
originalState.RootModule().Resources["test_instance.foo"].Primary.Ephemeral.ConnInfo = nil
2014-07-28 05:38:41 +02:00
2014-09-19 02:16:09 +02:00
actualStr := strings.TrimSpace(backupState.String())
expectedStr := strings.TrimSpace(originalState.String())
if actualStr != expectedStr {
t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr)
2014-07-28 05:38:41 +02:00
}
2014-06-19 21:12:24 +02:00
}
2014-06-19 06:36:44 +02:00
func TestApply_stateNoExist(t *testing.T) {
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
2014-06-19 06:36:44 +02:00
}
args := []string{
"idontexist.tfstate",
2014-06-19 06:36:44 +02:00
testFixturePath("apply"),
}
if code := c.Run(args); code != 1 {
t.Fatalf("bad: \n%s", ui.OutputWriter.String())
}
}
2014-07-18 20:37:27 +02:00
func TestApply_vars(t *testing.T) {
statePath := testTempFile(t)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
actual := ""
p.DiffFn = func(
2014-09-17 20:15:07 +02:00
info *terraform.InstanceInfo,
s *terraform.InstanceState,
2014-09-18 01:33:24 +02:00
c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
2014-07-18 20:37:27 +02:00
if v, ok := c.Config["value"]; ok {
actual = v.(string)
}
2014-09-18 01:33:24 +02:00
return &terraform.InstanceDiff{}, nil
2014-07-18 20:37:27 +02:00
}
args := []string{
"-var", "foo=bar",
"-state", statePath,
testFixturePath("apply-vars"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if actual != "bar" {
t.Fatal("didn't work")
}
}
2014-07-18 23:00:40 +02:00
func TestApply_varFile(t *testing.T) {
varFilePath := testTempFile(t)
if err := ioutil.WriteFile(varFilePath, []byte(applyVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
statePath := testTempFile(t)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
actual := ""
p.DiffFn = func(
2014-09-17 20:15:07 +02:00
info *terraform.InstanceInfo,
s *terraform.InstanceState,
2014-09-18 01:33:24 +02:00
c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
2014-07-18 23:00:40 +02:00
if v, ok := c.Config["value"]; ok {
actual = v.(string)
}
2014-09-18 01:33:24 +02:00
return &terraform.InstanceDiff{}, nil
2014-07-18 23:00:40 +02:00
}
args := []string{
"-var-file", varFilePath,
"-state", statePath,
testFixturePath("apply-vars"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if actual != "bar" {
t.Fatal("didn't work")
}
}
func TestApply_varFileDefault(t *testing.T) {
varFileDir := testTempDir(t)
varFilePath := filepath.Join(varFileDir, "terraform.tfvars")
if err := ioutil.WriteFile(varFilePath, []byte(applyVarFile), 0644); err != nil {
t.Fatalf("err: %s", err)
}
statePath := testTempFile(t)
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(varFileDir); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
actual := ""
p.DiffFn = func(
2014-09-17 20:15:07 +02:00
info *terraform.InstanceInfo,
s *terraform.InstanceState,
2014-09-18 01:33:24 +02:00
c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
if v, ok := c.Config["value"]; ok {
actual = v.(string)
}
2014-09-18 01:33:24 +02:00
return &terraform.InstanceDiff{}, nil
}
args := []string{
"-state", statePath,
testFixturePath("apply-vars"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
if actual != "bar" {
t.Fatal("didn't work")
}
}
2014-07-28 05:38:41 +02:00
func TestApply_backup(t *testing.T) {
originalState := &terraform.State{
2014-09-17 20:15:07 +02:00
Modules: []*terraform.ModuleState{
&terraform.ModuleState{
Path: []string{"root"},
Resources: map[string]*terraform.ResourceState{
"test_instance.foo": &terraform.ResourceState{
Type: "test_instance",
Primary: &terraform.InstanceState{
ID: "bar",
},
},
},
2014-07-28 05:38:41 +02:00
},
},
}
statePath := testStateFile(t, originalState)
backupPath := testTempFile(t)
p := testProvider()
2014-09-18 01:33:24 +02:00
p.DiffReturn = &terraform.InstanceDiff{
2014-07-28 05:38:41 +02:00
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
// Run the apply command pointing to our existing state
args := []string{
"-state", statePath,
"-backup", backupPath,
testFixturePath("apply"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
// Verify a new state exists
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
// Should have a backup file
f, err = os.Open(backupPath)
if err != nil {
t.Fatalf("err: %s", err)
}
backupState, err := terraform.ReadState(f)
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
2014-09-17 20:15:07 +02:00
actual := backupState.RootModule().Resources["test_instance.foo"]
expected := originalState.RootModule().Resources["test_instance.foo"]
2014-07-28 05:38:41 +02:00
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("bad: %#v %#v", actual, expected)
}
}
func TestApply_disableBackup(t *testing.T) {
2014-09-18 19:40:23 +02:00
originalState := testState()
2014-07-28 05:38:41 +02:00
statePath := testStateFile(t, originalState)
p := testProvider()
2014-09-18 01:33:24 +02:00
p.DiffReturn = &terraform.InstanceDiff{
2014-07-28 05:38:41 +02:00
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}
ui := new(cli.MockUi)
c := &ApplyCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
// Run the apply command pointing to our existing state
args := []string{
"-state", statePath,
"-backup", "-",
testFixturePath("apply"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
// Verify that the provider was called with the existing state
2014-09-18 19:40:23 +02:00
actual := strings.TrimSpace(p.DiffState.String())
expected := strings.TrimSpace(testApplyDisableBackupStr)
if actual != expected {
t.Fatalf("bad:\n\n%s", actual)
2014-07-28 05:38:41 +02:00
}
2014-09-18 19:40:23 +02:00
actual = strings.TrimSpace(p.ApplyState.String())
expected = strings.TrimSpace(testApplyDisableBackupStateStr)
if actual != expected {
t.Fatalf("bad:\n\n%s", actual)
2014-07-28 05:38:41 +02:00
}
// Verify a new state exists
if _, err := os.Stat(statePath); err != nil {
t.Fatalf("err: %s", err)
}
f, err := os.Open(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
defer f.Close()
state, err := terraform.ReadState(f)
if err != nil {
t.Fatalf("err: %s", err)
}
if state == nil {
t.Fatal("state should not be nil")
}
// Ensure there is no backup
_, err = os.Stat(statePath + DefaultBackupExtention)
if err == nil || !os.IsNotExist(err) {
t.Fatalf("backup should not exist")
}
}
2014-07-18 23:00:40 +02:00
const applyVarFile = `
foo = "bar"
`
2014-09-18 19:40:23 +02:00
const testApplyDisableBackupStr = `
ID = bar
`
const testApplyDisableBackupStateStr = `
ID = bar
`
const testApplyStateStr = `
ID = bar
`
const testApplyStateDiffStr = `
ID = bar
`