opentf/state/testing.go

package state

import (
	"reflect"
	"testing"

	"github.com/hashicorp/terraform/terraform"
)

// TestState is a helper for testing state implementations. It is expected
// that the given implementation is pre-loaded with the TestStateInitial
// state.
func TestState(t *testing.T, s State) {
	if err := s.RefreshState(); err != nil {
		t.Fatalf("err: %s", err)
	}

	// Check that the initial state is correct.
	// These do have different Lineages, but we will replace current below.
	initial := TestStateInitial()
	if state := s.State(); !state.Equal(initial) {
		t.Fatalf("state does not match expected initial state:\n%#v\n\n%#v", state, initial)
	}

	// Now we've proven that the state we're starting with is an initial
	// state, we'll complete our work here with that state, since otherwise
	// further writes would violate the invariant that we only try to write
	// states that share the same lineage as what was initially written.
	current := s.State()

	// Write a new state and verify that we have it
	current.AddModuleState(&terraform.ModuleState{
		Path: []string{"root"},
		Outputs: map[string]*terraform.OutputState{
			"bar": &terraform.OutputState{
				Type:      "string",
				Sensitive: false,
				Value:     "baz",
			},
		},
	})

	if err := s.WriteState(current); err != nil {
		t.Fatalf("err: %s", err)
	}

	if actual := s.State(); !actual.Equal(current) {
		t.Fatalf("bad:\n%#v\n\n%#v", actual, current)
	}

	// Test persistence
	if err := s.PersistState(); err != nil {
		t.Fatalf("err: %s", err)
	}

	// Refresh if we got it
	if err := s.RefreshState(); err != nil {
		t.Fatalf("err: %s", err)
	}

	if s.State().Lineage != current.Lineage {
		t.Fatalf("Lineage changed from %s to %s", s.State().Lineage, current.Lineage)
	}

	// Just set the serials the same... Then compare.
	actual := s.State()
	if !actual.Equal(current) {
		t.Fatalf("bad: %#v\n\n%#v", actual, current)
	}

	// Same serial
	serial := s.State().Serial
	if err := s.WriteState(current); err != nil {
		t.Fatalf("err: %s", err)
	}
	if err := s.PersistState(); err != nil {
		t.Fatalf("err: %s", err)
	}

	if s.State().Serial != serial {
		t.Fatalf("serial changed after persisting with no changes: got %d, want %d", s.State().Serial, serial)
	}

	// Change the serial
	current = current.DeepCopy()
	current.Modules = []*terraform.ModuleState{
		&terraform.ModuleState{
			Path: []string{"root", "somewhere"},
			Outputs: map[string]*terraform.OutputState{
				"serialCheck": &terraform.OutputState{
					Type:      "string",
					Sensitive: false,
					Value:     "true",
				},
			},
		},
	}
	if err := s.WriteState(current); err != nil {
		t.Fatalf("err: %s", err)
	}
	if err := s.PersistState(); err != nil {
		t.Fatalf("err: %s", err)
	}

	if s.State().Serial <= serial {
		t.Fatalf("serial incorrect after persisting with changes: got %d, want > %d", s.State().Serial, serial)
	}

	if s.State().Version != current.Version {
		t.Fatalf("Version changed from %d to %d", s.State().Version, current.Version)
	}

	if s.State().TFVersion != current.TFVersion {
		t.Fatalf("TFVersion changed from %s to %s", s.State().TFVersion, current.TFVersion)
	}

	// verify that Lineage doesn't change along with Serial, or during copying.
	if s.State().Lineage != current.Lineage {
		t.Fatalf("Lineage changed from %s to %s", s.State().Lineage, current.Lineage)
	}

	// Check that State() returns a copy by modifying the copy and comparing
	// to the current state.
	stateCopy := s.State()
	stateCopy.Serial++
	if reflect.DeepEqual(stateCopy, s.State()) {
		t.Fatal("State() should return a copy")
	}

	// our current expected state should also marhsal identically to the persisted state
	if current.MarshalEqual(s.State()) {
		t.Fatalf("Persisted state altered unexpectedly. Expected: %#v\b Got: %#v", current, s.State())
	}
}

// TestStateInitial is the initial state that a State should have
// for TestState.
func TestStateInitial() *terraform.State {
	initial := &terraform.State{
		Modules: []*terraform.ModuleState{
			&terraform.ModuleState{
				Path: []string{"root", "child"},
				Outputs: map[string]*terraform.OutputState{
					"foo": &terraform.OutputState{
						Type:      "string",
						Sensitive: false,
						Value:     "bar",
					},
				},
			},
		},
	}

	initial.Init()

	return initial
}