314 lines
7.6 KiB
Go
314 lines
7.6 KiB
Go
|
package backend
|
||
|
|
||
|
import (
|
||
|
"reflect"
|
||
|
"sort"
|
||
|
"testing"
|
||
|
|
||
|
"github.com/hashicorp/terraform/config"
|
||
|
"github.com/hashicorp/terraform/state"
|
||
|
"github.com/hashicorp/terraform/terraform"
|
||
|
)
|
||
|
|
||
|
// TestBackendConfig validates and configures the backend with the
|
||
|
// given configuration.
|
||
|
func TestBackendConfig(t *testing.T, b Backend, c map[string]interface{}) Backend {
|
||
|
t.Helper()
|
||
|
|
||
|
// Get the proper config structure
|
||
|
rc, err := config.NewRawConfig(c)
|
||
|
if err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
conf := terraform.NewResourceConfig(rc)
|
||
|
|
||
|
// Validate
|
||
|
warns, errs := b.Validate(conf)
|
||
|
if len(warns) > 0 {
|
||
|
t.Fatalf("warnings: %s", warns)
|
||
|
}
|
||
|
if len(errs) > 0 {
|
||
|
t.Fatalf("errors: %s", errs)
|
||
|
}
|
||
|
|
||
|
// Configure
|
||
|
if err := b.Configure(conf); err != nil {
|
||
|
t.Fatalf("err: %s", err)
|
||
|
}
|
||
|
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
// TestBackend will test the functionality of a Backend. The backend is
|
||
|
// assumed to already be configured. This will test state functionality.
|
||
|
// If the backend reports it doesn't support multi-state by returning the
|
||
|
// error ErrNamedStatesNotSupported, then it will not test that.
|
||
|
//
|
||
|
// If you want to test locking, two backends must be given. If b2 is nil,
|
||
|
// then state locking won't be tested.
|
||
|
func TestBackend(t *testing.T, b1, b2 Backend) {
|
||
|
t.Helper()
|
||
|
|
||
|
testBackendStates(t, b1)
|
||
|
|
||
|
if b2 != nil {
|
||
|
testBackendStateLock(t, b1, b2)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func testBackendStates(t *testing.T, b Backend) {
|
||
|
t.Helper()
|
||
|
|
||
|
states, err := b.States()
|
||
|
if err == ErrNamedStatesNotSupported {
|
||
|
t.Logf("TestBackend: named states not supported in %T, skipping", b)
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// Test it starts with only the default
|
||
|
if len(states) != 1 || states[0] != DefaultStateName {
|
||
|
t.Fatalf("should only have default to start: %#v", states)
|
||
|
}
|
||
|
|
||
|
// Create a couple states
|
||
|
foo, err := b.State("foo")
|
||
|
if err != nil {
|
||
|
t.Fatalf("error: %s", err)
|
||
|
}
|
||
|
if err := foo.RefreshState(); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
if v := foo.State(); v.HasResources() {
|
||
|
t.Fatalf("should be empty: %s", v)
|
||
|
}
|
||
|
|
||
|
bar, err := b.State("bar")
|
||
|
if err != nil {
|
||
|
t.Fatalf("error: %s", err)
|
||
|
}
|
||
|
if err := bar.RefreshState(); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
if v := bar.State(); v.HasResources() {
|
||
|
t.Fatalf("should be empty: %s", v)
|
||
|
}
|
||
|
|
||
|
// Verify they are distinct states that can be read back from storage
|
||
|
{
|
||
|
// start with a fresh state, and record the lineage being
|
||
|
// written to "bar"
|
||
|
barState := terraform.NewState()
|
||
|
|
||
|
// creating the named state may have created a lineage, so use that if it exists.
|
||
|
if s := bar.State(); s != nil && s.Lineage != "" {
|
||
|
barState.Lineage = s.Lineage
|
||
|
}
|
||
|
barLineage := barState.Lineage
|
||
|
|
||
|
// the foo lineage should be distinct from bar, and unchanged after
|
||
|
// modifying bar
|
||
|
fooState := terraform.NewState()
|
||
|
// creating the named state may have created a lineage, so use that if it exists.
|
||
|
if s := foo.State(); s != nil && s.Lineage != "" {
|
||
|
fooState.Lineage = s.Lineage
|
||
|
}
|
||
|
fooLineage := fooState.Lineage
|
||
|
|
||
|
// write a known state to foo
|
||
|
if err := foo.WriteState(fooState); err != nil {
|
||
|
t.Fatal("error writing foo state:", err)
|
||
|
}
|
||
|
if err := foo.PersistState(); err != nil {
|
||
|
t.Fatal("error persisting foo state:", err)
|
||
|
}
|
||
|
|
||
|
// write a distinct known state to bar
|
||
|
if err := bar.WriteState(barState); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
if err := bar.PersistState(); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
|
||
|
// verify that foo is unchanged with the existing state manager
|
||
|
if err := foo.RefreshState(); err != nil {
|
||
|
t.Fatal("error refreshing foo:", err)
|
||
|
}
|
||
|
fooState = foo.State()
|
||
|
switch {
|
||
|
case fooState == nil:
|
||
|
t.Fatal("nil state read from foo")
|
||
|
case fooState.Lineage == barLineage:
|
||
|
t.Fatalf("bar lineage read from foo: %#v", fooState)
|
||
|
case fooState.Lineage != fooLineage:
|
||
|
t.Fatal("foo lineage alterred")
|
||
|
}
|
||
|
|
||
|
// fetch foo again from the backend
|
||
|
foo, err = b.State("foo")
|
||
|
if err != nil {
|
||
|
t.Fatal("error re-fetching state:", err)
|
||
|
}
|
||
|
if err := foo.RefreshState(); err != nil {
|
||
|
t.Fatal("error refreshing foo:", err)
|
||
|
}
|
||
|
fooState = foo.State()
|
||
|
switch {
|
||
|
case fooState == nil:
|
||
|
t.Fatal("nil state read from foo")
|
||
|
case fooState.Lineage != fooLineage:
|
||
|
t.Fatal("incorrect state returned from backend")
|
||
|
}
|
||
|
|
||
|
// fetch the bar again from the backend
|
||
|
bar, err = b.State("bar")
|
||
|
if err != nil {
|
||
|
t.Fatal("error re-fetching state:", err)
|
||
|
}
|
||
|
if err := bar.RefreshState(); err != nil {
|
||
|
t.Fatal("error refreshing bar:", err)
|
||
|
}
|
||
|
barState = bar.State()
|
||
|
switch {
|
||
|
case barState == nil:
|
||
|
t.Fatal("nil state read from bar")
|
||
|
case barState.Lineage != barLineage:
|
||
|
t.Fatal("incorrect state returned from backend")
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Verify we can now list them
|
||
|
{
|
||
|
// we determined that named stated are supported earlier
|
||
|
states, err := b.States()
|
||
|
if err != nil {
|
||
|
t.Fatal(err)
|
||
|
}
|
||
|
|
||
|
sort.Strings(states)
|
||
|
expected := []string{"bar", "default", "foo"}
|
||
|
if !reflect.DeepEqual(states, expected) {
|
||
|
t.Fatalf("bad: %#v", states)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Delete some states
|
||
|
if err := b.DeleteState("foo"); err != nil {
|
||
|
t.Fatalf("err: %s", err)
|
||
|
}
|
||
|
|
||
|
// Verify the default state can't be deleted
|
||
|
if err := b.DeleteState(DefaultStateName); err == nil {
|
||
|
t.Fatal("expected error")
|
||
|
}
|
||
|
|
||
|
// Create and delete the foo state again.
|
||
|
// Make sure that there are no leftover artifacts from a deleted state
|
||
|
// preventing re-creation.
|
||
|
foo, err = b.State("foo")
|
||
|
if err != nil {
|
||
|
t.Fatalf("error: %s", err)
|
||
|
}
|
||
|
if err := foo.RefreshState(); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
if v := foo.State(); v.HasResources() {
|
||
|
t.Fatalf("should be empty: %s", v)
|
||
|
}
|
||
|
// and delete it again
|
||
|
if err := b.DeleteState("foo"); err != nil {
|
||
|
t.Fatalf("err: %s", err)
|
||
|
}
|
||
|
|
||
|
// Verify deletion
|
||
|
{
|
||
|
states, err := b.States()
|
||
|
if err == ErrNamedStatesNotSupported {
|
||
|
t.Logf("TestBackend: named states not supported in %T, skipping", b)
|
||
|
return
|
||
|
}
|
||
|
|
||
|
sort.Strings(states)
|
||
|
expected := []string{"bar", "default"}
|
||
|
if !reflect.DeepEqual(states, expected) {
|
||
|
t.Fatalf("bad: %#v", states)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func testBackendStateLock(t *testing.T, b1, b2 Backend) {
|
||
|
t.Helper()
|
||
|
|
||
|
// Get the default state for each
|
||
|
b1StateMgr, err := b1.State(DefaultStateName)
|
||
|
if err != nil {
|
||
|
t.Fatalf("error: %s", err)
|
||
|
}
|
||
|
if err := b1StateMgr.RefreshState(); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
|
||
|
// Fast exit if this doesn't support locking at all
|
||
|
if _, ok := b1StateMgr.(state.Locker); !ok {
|
||
|
t.Logf("TestBackend: backend %T doesn't support state locking, not testing", b1)
|
||
|
return
|
||
|
}
|
||
|
|
||
|
t.Logf("TestBackend: testing state locking for %T", b1)
|
||
|
|
||
|
b2StateMgr, err := b2.State(DefaultStateName)
|
||
|
if err != nil {
|
||
|
t.Fatalf("error: %s", err)
|
||
|
}
|
||
|
if err := b2StateMgr.RefreshState(); err != nil {
|
||
|
t.Fatalf("bad: %s", err)
|
||
|
}
|
||
|
|
||
|
// Reassign so its obvious whats happening
|
||
|
lockerA := b1StateMgr.(state.Locker)
|
||
|
lockerB := b2StateMgr.(state.Locker)
|
||
|
|
||
|
infoA := state.NewLockInfo()
|
||
|
infoA.Operation = "test"
|
||
|
infoA.Who = "clientA"
|
||
|
|
||
|
infoB := state.NewLockInfo()
|
||
|
infoB.Operation = "test"
|
||
|
infoB.Who = "clientB"
|
||
|
|
||
|
lockIDA, err := lockerA.Lock(infoA)
|
||
|
if err != nil {
|
||
|
t.Fatal("unable to get initial lock:", err)
|
||
|
}
|
||
|
|
||
|
// If the lock ID is blank, assume locking is disabled
|
||
|
if lockIDA == "" {
|
||
|
t.Logf("TestBackend: %T: empty string returned for lock, assuming disabled", b1)
|
||
|
return
|
||
|
}
|
||
|
|
||
|
_, err = lockerB.Lock(infoB)
|
||
|
if err == nil {
|
||
|
lockerA.Unlock(lockIDA)
|
||
|
t.Fatal("client B obtained lock while held by client A")
|
||
|
}
|
||
|
|
||
|
if err := lockerA.Unlock(lockIDA); err != nil {
|
||
|
t.Fatal("error unlocking client A", err)
|
||
|
}
|
||
|
|
||
|
lockIDB, err := lockerB.Lock(infoB)
|
||
|
if err != nil {
|
||
|
t.Fatal("unable to obtain lock from client B")
|
||
|
}
|
||
|
|
||
|
if lockIDB == lockIDA {
|
||
|
t.Fatalf("duplicate lock IDs: %q", lockIDB)
|
||
|
}
|
||
|
|
||
|
if err = lockerB.Unlock(lockIDB); err != nil {
|
||
|
t.Fatal("error unlocking client B:", err)
|
||
|
}
|
||
|
|
||
|
}
|