terraform/helper/resource/testing_test.go

281 lines
4.8 KiB
Go
Raw Normal View History

package resource
import (
2014-07-10 19:30:41 +02:00
"fmt"
"os"
"testing"
"github.com/hashicorp/terraform/terraform"
)
func init() {
testTesting = true
if err := os.Setenv(TestEnvVar, "1"); err != nil {
panic(err)
}
}
func TestTest(t *testing.T) {
mp := testProvider()
mp.ApplyReturn = &terraform.InstanceState{
ID: "foo",
}
checkDestroy := false
checkStep := false
checkDestroyFn := func(*terraform.State) error {
checkDestroy = true
return nil
}
checkStepFn := func(s *terraform.State) error {
checkStep = true
rs, ok := s.RootModule().Resources["test_instance.foo"]
if !ok {
t.Error("test_instance.foo is not present")
return nil
}
is := rs.Primary
if is.ID != "foo" {
t.Errorf("bad check ID: %s", is.ID)
}
return nil
}
mt := new(mockT)
Test(mt, TestCase{
Providers: map[string]terraform.ResourceProvider{
"test": mp,
},
CheckDestroy: checkDestroyFn,
Steps: []TestStep{
TestStep{
Config: testConfigStr,
Check: checkStepFn,
},
},
})
if mt.failed() {
t.Fatalf("test failed: %s", mt.failMessage())
}
if !checkStep {
t.Fatal("didn't call check for step")
}
if !checkDestroy {
t.Fatal("didn't call check for destroy")
}
}
func TestTest_empty(t *testing.T) {
destroyCalled := false
checkDestroyFn := func(*terraform.State) error {
destroyCalled = true
return nil
}
mt := new(mockT)
Test(mt, TestCase{
CheckDestroy: checkDestroyFn,
})
if mt.failed() {
t.Fatal("test failed")
}
if destroyCalled {
t.Fatal("should not call check destroy if there is no steps")
}
}
func TestTest_noEnv(t *testing.T) {
// Unset the variable
if err := os.Setenv(TestEnvVar, ""); err != nil {
t.Fatalf("err: %s", err)
}
2014-07-10 19:30:41 +02:00
defer os.Setenv(TestEnvVar, "1")
mt := new(mockT)
Test(mt, TestCase{})
if !mt.SkipCalled {
t.Fatal("skip not called")
}
}
2014-07-10 22:12:47 +02:00
func TestTest_preCheck(t *testing.T) {
called := false
mt := new(mockT)
Test(mt, TestCase{
PreCheck: func() { called = true },
2014-07-10 22:12:47 +02:00
})
if !called {
t.Fatal("precheck should be called")
}
}
2014-07-10 19:30:41 +02:00
func TestTest_stepError(t *testing.T) {
mp := testProvider()
mp.ApplyReturn = &terraform.InstanceState{
2014-07-10 19:30:41 +02:00
ID: "foo",
}
checkDestroy := false
checkDestroyFn := func(*terraform.State) error {
checkDestroy = true
return nil
}
checkStepFn := func(*terraform.State) error {
return fmt.Errorf("error")
}
mt := new(mockT)
Test(mt, TestCase{
Providers: map[string]terraform.ResourceProvider{
"test": mp,
},
CheckDestroy: checkDestroyFn,
Steps: []TestStep{
TestStep{
Config: testConfigStr,
Check: checkStepFn,
},
},
})
if !mt.failed() {
t.Fatal("test should've failed")
}
t.Logf("Fail message: %s", mt.failMessage())
if !checkDestroy {
t.Fatal("didn't call check for destroy")
}
}
func TestComposeTestCheckFunc(t *testing.T) {
cases := []struct {
F []TestCheckFunc
Result string
}{
{
F: []TestCheckFunc{
func(*terraform.State) error { return nil },
},
Result: "",
},
{
F: []TestCheckFunc{
func(*terraform.State) error {
return fmt.Errorf("error")
},
func(*terraform.State) error { return nil },
},
Result: "error",
},
{
F: []TestCheckFunc{
func(*terraform.State) error { return nil },
func(*terraform.State) error {
return fmt.Errorf("error")
},
},
Result: "error",
},
{
F: []TestCheckFunc{
func(*terraform.State) error { return nil },
func(*terraform.State) error { return nil },
},
Result: "",
},
}
for i, tc := range cases {
f := ComposeTestCheckFunc(tc.F...)
err := f(nil)
if err == nil {
err = fmt.Errorf("")
}
if tc.Result != err.Error() {
t.Fatalf("Case %d bad: %s", i, err)
}
}
}
// mockT implements TestT for testing
type mockT struct {
ErrorCalled bool
ErrorArgs []interface{}
FatalCalled bool
FatalArgs []interface{}
SkipCalled bool
SkipArgs []interface{}
f bool
}
func (t *mockT) Error(args ...interface{}) {
t.ErrorCalled = true
t.ErrorArgs = args
t.f = true
}
func (t *mockT) Fatal(args ...interface{}) {
t.FatalCalled = true
t.FatalArgs = args
t.f = true
}
func (t *mockT) Skip(args ...interface{}) {
t.SkipCalled = true
t.SkipArgs = args
t.f = true
}
func (t *mockT) failed() bool {
return t.f
}
func (t *mockT) failMessage() string {
if t.FatalCalled {
return t.FatalArgs[0].(string)
} else if t.ErrorCalled {
return t.ErrorArgs[0].(string)
} else if t.SkipCalled {
return t.SkipArgs[0].(string)
}
return "unknown"
}
func testProvider() *terraform.MockResourceProvider {
mp := new(terraform.MockResourceProvider)
2014-07-10 19:30:41 +02:00
mp.DiffReturn = &terraform.ResourceDiff{
Attributes: map[string]*terraform.ResourceAttrDiff{
"foo": &terraform.ResourceAttrDiff{
New: "bar",
},
},
}
mp.ResourcesReturn = []terraform.ResourceType{
terraform.ResourceType{Name: "test_instance"},
}
return mp
}
const testConfigStr = `
resource "test_instance" "foo" {}
`