github.com/rstandt/terraform@v0.12.32-0.20230710220336-b1063613405c/state/remote/state_test.go

package remote

import (
	"log"
	"sync"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/zclconf/go-cty/cty"

	"github.com/hashicorp/terraform/states"
	"github.com/hashicorp/terraform/states/statefile"
	"github.com/hashicorp/terraform/states/statemgr"
	"github.com/hashicorp/terraform/version"
)

func TestState_impl(t *testing.T) {
	var _ statemgr.Reader = new(State)
	var _ statemgr.Writer = new(State)
	var _ statemgr.Persister = new(State)
	var _ statemgr.Refresher = new(State)
	var _ statemgr.Locker = new(State)
}

func TestStateRace(t *testing.T) {
	s := &State{
		Client: nilClient{},
	}

	current := states.NewState()

	var wg sync.WaitGroup

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			s.WriteState(current)
			s.PersistState()
			s.RefreshState()
		}()
	}
	wg.Wait()
}

// testCase encapsulates a test state test
type testCase struct {
	name string
	// A function to mutate state and return a cleanup function
	mutationFunc func(*State) (*states.State, func())
	// The expected request to have taken place
	expectedRequest mockClientRequest
	// Mark this case as not having a request
	noRequest bool
}

// isRequested ensures a test that is specified as not having
// a request doesn't have one by checking if a method exists
// on the expectedRequest.
func (tc testCase) isRequested(t *testing.T) bool {
	hasMethod := tc.expectedRequest.Method != ""
	if tc.noRequest && hasMethod {
		t.Fatalf("expected no content for %q but got: %v", tc.name, tc.expectedRequest)
	}
	return !tc.noRequest
}

func TestStatePersist(t *testing.T) {
	testCases := []testCase{
		// Refreshing state before we run the test loop causes a GET
		{
			name: "refresh state",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				return mgr.State(), func() {}
			},
			expectedRequest: mockClientRequest{
				Method: "Get",
				Content: map[string]interface{}{
					"version":           4.0, // encoding/json decodes this as float64 by default
					"lineage":           "mock-lineage",
					"serial":            1.0, // encoding/json decodes this as float64 by default
					"terraform_version": "0.0.0",
					"outputs":           map[string]interface{}{},
					"resources":         []interface{}{},
				},
			},
		},
		{
			name: "change lineage",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				originalLineage := mgr.lineage
				mgr.lineage = "some-new-lineage"
				return mgr.State(), func() {
					mgr.lineage = originalLineage
				}
			},
			expectedRequest: mockClientRequest{
				Method: "Put",
				Content: map[string]interface{}{
					"version":           4.0, // encoding/json decodes this as float64 by default
					"lineage":           "some-new-lineage",
					"serial":            2.0, // encoding/json decodes this as float64 by default
					"terraform_version": version.Version,
					"outputs":           map[string]interface{}{},
					"resources":         []interface{}{},
				},
			},
		},
		{
			name: "change serial",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				originalSerial := mgr.serial
				mgr.serial++
				return mgr.State(), func() {
					mgr.serial = originalSerial
				}
			},
			expectedRequest: mockClientRequest{
				Method: "Put",
				Content: map[string]interface{}{
					"version":           4.0, // encoding/json decodes this as float64 by default
					"lineage":           "mock-lineage",
					"serial":            4.0, // encoding/json decodes this as float64 by default
					"terraform_version": version.Version,
					"outputs":           map[string]interface{}{},
					"resources":         []interface{}{},
				},
			},
		},
		{
			name: "add output to state",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				s := mgr.State()
				s.RootModule().SetOutputValue("foo", cty.StringVal("bar"), false)
				return s, func() {}
			},
			expectedRequest: mockClientRequest{
				Method: "Put",
				Content: map[string]interface{}{
					"version":           4.0, // encoding/json decodes this as float64 by default
					"lineage":           "mock-lineage",
					"serial":            3.0, // encoding/json decodes this as float64 by default
					"terraform_version": version.Version,
					"outputs": map[string]interface{}{
						"foo": map[string]interface{}{
							"type":  "string",
							"value": "bar",
						},
					},
					"resources": []interface{}{},
				},
			},
		},
		{
			name: "mutate state bar -> baz",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				s := mgr.State()
				s.RootModule().SetOutputValue("foo", cty.StringVal("baz"), false)
				return s, func() {}
			},
			expectedRequest: mockClientRequest{
				Method: "Put",
				Content: map[string]interface{}{
					"version":           4.0, // encoding/json decodes this as float64 by default
					"lineage":           "mock-lineage",
					"serial":            4.0, // encoding/json decodes this as float64 by default
					"terraform_version": version.Version,
					"outputs": map[string]interface{}{
						"foo": map[string]interface{}{
							"type":  "string",
							"value": "baz",
						},
					},
					"resources": []interface{}{},
				},
			},
		},
		{
			name: "nothing changed",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				s := mgr.State()
				return s, func() {}
			},
			noRequest: true,
		},
		{
			name: "reset serial (force push style)",
			mutationFunc: func(mgr *State) (*states.State, func()) {
				mgr.serial = 2
				return mgr.State(), func() {}
			},
			expectedRequest: mockClientRequest{
				Method: "Put",
				Content: map[string]interface{}{
					"version":           4.0, // encoding/json decodes this as float64 by default
					"lineage":           "mock-lineage",
					"serial":            3.0, // encoding/json decodes this as float64 by default
					"terraform_version": version.Version,
					"outputs": map[string]interface{}{
						"foo": map[string]interface{}{
							"type":  "string",
							"value": "baz",
						},
					},
					"resources": []interface{}{},
				},
			},
		},
	}

	// Initial setup of state just to give us a fixed starting point for our
	// test assertions below, or else we'd need to deal with
	// random lineage.
	mgr := &State{
		Client: &mockClient{
			current: []byte(`
				{
					"version": 4,
					"lineage": "mock-lineage",
					"serial": 1,
					"terraform_version":"0.0.0",
					"outputs": {},
					"resources": []
				}
			`),
		},
	}

	// In normal use (during a Terraform operation) we always refresh and read
	// before any writes would happen, so we'll mimic that here for realism.
	// NB This causes a GET to be logged so the first item in the test cases
	// must account for this
	if err := mgr.RefreshState(); err != nil {
		t.Fatalf("failed to RefreshState: %s", err)
	}

	// Our client is a mockClient which has a log we
	// use to check that operations generate expected requests
	mockClient := mgr.Client.(*mockClient)

	// logIdx tracks the current index of the log separate from
	// the loop iteration so we can check operations that don't
	// cause any requests to be generated
	logIdx := 0

	// Run tests in order.
	for _, tc := range testCases {
		s, cleanup := tc.mutationFunc(mgr)

		if err := mgr.WriteState(s); err != nil {
			t.Fatalf("failed to WriteState for %q: %s", tc.name, err)
		}
		if err := mgr.PersistState(); err != nil {
			t.Fatalf("failed to PersistState for %q: %s", tc.name, err)
		}

		if tc.isRequested(t) {
			// Get captured request from the mock client log
			// based on the index of the current test
			if logIdx >= len(mockClient.log) {
				t.Fatalf("request lock and index are out of sync on %q: idx=%d len=%d", tc.name, logIdx, len(mockClient.log))
			}
			loggedRequest := mockClient.log[logIdx]
			logIdx++
			if diff := cmp.Diff(tc.expectedRequest, loggedRequest); len(diff) > 0 {
				t.Fatalf("incorrect client requests for %q:\n%s", tc.name, diff)
			}
		}
		cleanup()
	}
	logCnt := len(mockClient.log)
	if logIdx != logCnt {
		log.Fatalf("not all requests were read. Expected logIdx to be %d but got %d", logCnt, logIdx)
	}
}

type migrationTestCase struct {
	name string
	// A function to generate a statefile
	stateFile func(*State) *statefile.File
	// The expected request to have taken place
	expectedRequest mockClientRequest
	// Mark this case as not having a request
	expectedError string
	// force flag passed to client
	force bool
}

func TestWriteStateForMigration(t *testing.T) {
	mgr := &State{
		Client: &mockClient{
			current: []byte(`
				{
					"version": 4,
					"lineage": "mock-lineage",
					"serial": 3,
					"terraform_version":"0.0.0",
					"outputs": {"foo": {"value":"bar", "type": "string"}},
					"resources": []
				}
			`),
		},
	}

	testCases := []migrationTestCase{
		// Refreshing state before we run the test loop causes a GET
		{
			name: "refresh state",
			stateFile: func(mgr *State) *statefile.File {
				return mgr.StateForMigration()
			},
			expectedRequest: mockClientRequest{
				Method: "Get",
				Content: map[string]interface{}{
					"version":           4.0,
					"lineage":           "mock-lineage",
					"serial":            3.0,
					"terraform_version": "0.0.0",
					"outputs":           map[string]interface{}{"foo": map[string]interface{}{"type": string("string"), "value": string("bar")}},
					"resources":         []interface{}{},
				},
			},
		},
		{
			name: "cannot import lesser serial without force",
			stateFile: func(mgr *State) *statefile.File {
				return statefile.New(mgr.state, mgr.lineage, 1)
			},
			expectedError: "cannot import state with serial 1 over newer state with serial 3",
		},
		{
			name: "cannot import differing lineage without force",
			stateFile: func(mgr *State) *statefile.File {
				return statefile.New(mgr.state, "different-lineage", mgr.serial)
			},
			expectedError: `cannot import state with lineage "different-lineage" over unrelated state with lineage "mock-lineage"`,
		},
		{
			name: "can import lesser serial with force",
			stateFile: func(mgr *State) *statefile.File {
				return statefile.New(mgr.state, mgr.lineage, 1)
			},
			expectedRequest: mockClientRequest{
				Method: "Force Put",
				Content: map[string]interface{}{
					"version":           4.0,
					"lineage":           "mock-lineage",
					"serial":            2.0,
					"terraform_version": version.Version,
					"outputs":           map[string]interface{}{"foo": map[string]interface{}{"type": string("string"), "value": string("bar")}},
					"resources":         []interface{}{},
				},
			},
			force: true,
		},
		{
			name: "cannot import differing lineage without force",
			stateFile: func(mgr *State) *statefile.File {
				return statefile.New(mgr.state, "different-lineage", mgr.serial)
			},
			expectedRequest: mockClientRequest{
				Method: "Force Put",
				Content: map[string]interface{}{
					"version":           4.0,
					"lineage":           "different-lineage",
					"serial":            3.0,
					"terraform_version": version.Version,
					"outputs":           map[string]interface{}{"foo": map[string]interface{}{"type": string("string"), "value": string("bar")}},
					"resources":         []interface{}{},
				},
			},
			force: true,
		},
	}

	// In normal use (during a Terraform operation) we always refresh and read
	// before any writes would happen, so we'll mimic that here for realism.
	// NB This causes a GET to be logged so the first item in the test cases
	// must account for this
	if err := mgr.RefreshState(); err != nil {
		t.Fatalf("failed to RefreshState: %s", err)
	}

	if err := mgr.WriteState(mgr.State()); err != nil {
		t.Fatalf("failed to write initial state: %s", err)
	}

	// Our client is a mockClient which has a log we
	// use to check that operations generate expected requests
	mockClient := mgr.Client.(*mockClient)

	if mockClient.force {
		t.Fatalf("client should not default to force")
	}

	// logIdx tracks the current index of the log separate from
	// the loop iteration so we can check operations that don't
	// cause any requests to be generated
	logIdx := 0

	for _, tc := range testCases {
		// Always reset client to not be force pushing
		mockClient.force = false
		sf := tc.stateFile(mgr)
		err := mgr.WriteStateForMigration(sf, tc.force)
		shouldError := tc.expectedError != ""

		// If we are expecting and error check it and move on
		if shouldError {
			if err == nil {
				t.Fatalf("test case %q should have failed with error %q", tc.name, tc.expectedError)
			} else if err.Error() != tc.expectedError {
				t.Fatalf("test case %q expected error %q but got %q", tc.name, tc.expectedError, err)
			}
			continue
		}

		if err != nil {
			t.Fatalf("test case %q failed: %v", tc.name, err)
		}

		if tc.force && !mockClient.force {
			t.Fatalf("test case %q should have enabled force push", tc.name)
		}

		// At this point we should just do a normal write and persist
		// as would happen from the CLI
		mgr.WriteState(mgr.State())
		mgr.PersistState()

		if logIdx >= len(mockClient.log) {
			t.Fatalf("request lock and index are out of sync on %q: idx=%d len=%d", tc.name, logIdx, len(mockClient.log))
		}
		loggedRequest := mockClient.log[logIdx]
		logIdx++
		if diff := cmp.Diff(tc.expectedRequest, loggedRequest); len(diff) > 0 {
			t.Fatalf("incorrect client requests for %q:\n%s", tc.name, diff)
		}
	}

	logCnt := len(mockClient.log)
	if logIdx != logCnt {
		log.Fatalf("not all requests were read. Expected logIdx to be %d but got %d", logCnt, logIdx)
	}
}