terraform/command/apply_test.go

252 lines
4.7 KiB
Go
Raw Normal View History

2014-06-19 06:36:44 +02:00
package command
import (
"os"
2014-06-19 21:12:24 +02:00
"reflect"
2014-06-19 06:36:44 +02:00
"testing"
"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{
TFConfig: testTFConfig(p),
Ui: ui,
}
args := []string{
2014-06-19 21:12:24 +02:00
"-init",
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_plan(t *testing.T) {
planPath := testPlanFile(t, new(terraform.Plan))
statePath := testTempFile(t)
2014-06-19 06:36:44 +02:00
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
TFConfig: testTFConfig(p),
Ui: ui,
}
args := []string{
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())
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")
}
}
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{
ShutdownCh: shutdownCh,
TFConfig: testTFConfig(p),
Ui: ui,
}
p.DiffFn = func(
*terraform.ResourceState,
*terraform.ResourceConfig) (*terraform.ResourceDiff, error) {
return &terraform.ResourceDiff{
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}, nil
}
p.ApplyFn = func(
*terraform.ResourceState,
*terraform.ResourceDiff) (*terraform.ResourceState, error) {
if !stopped {
stopped = true
close(stopCh)
<-stopReplyCh
}
return &terraform.ResourceState{
ID: "foo",
Attributes: map[string]string{
"ami": "2",
},
}, nil
}
go func() {
<-stopCh
shutdownCh <- struct{}{}
close(stopReplyCh)
}()
args := []string{
"-init",
statePath,
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")
}
if len(state.Resources) != 1 {
t.Fatalf("bad: %d", len(state.Resources))
}
}
func TestApply_state(t *testing.T) {
2014-06-19 21:12:24 +02:00
originalState := &terraform.State{
Resources: map[string]*terraform.ResourceState{
"test_instance.foo": &terraform.ResourceState{
ID: "bar",
Type: "test_instance",
},
},
}
statePath := testStateFile(t, originalState)
2014-06-19 21:12:24 +02:00
p := testProvider()
2014-07-01 05:49:49 +02:00
p.DiffReturn = &terraform.ResourceDiff{
Attributes: map[string]*terraform.ResourceAttrDiff{
"ami": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}
2014-06-19 21:12:24 +02:00
ui := new(cli.MockUi)
c := &ApplyCommand{
TFConfig: testTFConfig(p),
Ui: ui,
}
// Run the apply command pointing to our existing state
args := []string{
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
expectedState := originalState.Resources["test_instance.foo"]
if !reflect.DeepEqual(p.DiffState, expectedState) {
t.Fatalf("bad: %#v", p.DiffState)
}
2014-06-19 21:12:24 +02:00
if !reflect.DeepEqual(p.ApplyState, expectedState) {
t.Fatalf("bad: %#v", p.ApplyState)
}
// 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-06-19 06:36:44 +02:00
func TestApply_stateNoExist(t *testing.T) {
p := testProvider()
ui := new(cli.MockUi)
c := &ApplyCommand{
TFConfig: testTFConfig(p),
Ui: ui,
}
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())
}
}