Add test coverage of (m *Meta) prepareBackend()

Author: SarahFrench

internal/command/meta_backend.go

@@ -1552,7 +1552,7 @@ func (m *Meta) prepareBackend(root *configs.Module) (backendrun.OperationsBacken
 			return nil, diags
 		}
 
-		// TODO - Use locks from here in opts below
+		// TODO(SarahFrench/radeksimko): Use locks from here in opts below
 		_, lDiags := m.lockedDependencies()
 		diags = diags.Append(lDiags)
 		if lDiags.HasErrors() {
@@ -1562,7 +1562,7 @@ func (m *Meta) prepareBackend(root *configs.Module) (backendrun.OperationsBacken
 		opts = &BackendOpts{
 			StateStoreConfig: root.StateStore,
 			ProviderFactory:  factory,
-			// TODO - update once other work is merged into main
+			// TODO(SarahFrench/radeksimko): update once other work is merged into main
 			// Locks:            locks,
 		}
 	default:

internal/command/meta_backend_test.go

@@ -31,6 +31,7 @@ import (
 	"github.com/zclconf/go-cty/cty"
 
 	backendInit "github.com/hashicorp/terraform/internal/backend/init"
+	"github.com/hashicorp/terraform/internal/backend/local"
 	backendLocal "github.com/hashicorp/terraform/internal/backend/local"
 	backendInmem "github.com/hashicorp/terraform/internal/backend/remote-state/inmem"
 )
@@ -2520,6 +2521,106 @@ func TestMeta_getStateStoreProviderFactory(t *testing.T) {
 	})
 }
 
+func TestMetaBackend_prepareBackend(t *testing.T) {
+	t.Run("it returns a cloud backend from cloud backend config", func(t *testing.T) {
+		// Create a temporary working directory with cloud configuration in
+		td := t.TempDir()
+		testCopyDir(t, testFixturePath("cloud-config"), td)
+		t.Chdir(td)
+
+		m := testMetaBackend(t, nil)
+
+		// Get the cloud config
+		mod, loadDiags := m.loadSingleModule(td)
+		if loadDiags.HasErrors() {
+			t.Fatalf("unexpected error when loading test config: %s", loadDiags.Err())
+		}
+
+		// We cannot initialize a cloud backend so we instead check
+		// the init error is referencing HCP Terraform
+		_, bDiags := m.prepareBackend(mod)
+		if !bDiags.HasErrors() {
+			t.Fatal("expected error but got none")
+		}
+		wantErr := "HCP Terraform or Terraform Enterprise initialization required: please run \"terraform init\""
+		if !strings.Contains(bDiags.Err().Error(), wantErr) {
+			t.Fatalf("expected error to contain %q, but got: %q",
+				wantErr,
+				bDiags.Err())
+		}
+	})
+	t.Run("it returns a backend from backend config", func(t *testing.T) {
+		// Create a temporary working directory with backend configuration in
+		td := t.TempDir()
+		testCopyDir(t, testFixturePath("backend-unchanged"), td)
+		t.Chdir(td)
+
+		m := testMetaBackend(t, nil)
+
+		// Get the backend config
+		mod, loadDiags := m.loadSingleModule(td)
+		if loadDiags.HasErrors() {
+			t.Fatalf("unexpected error when loading test config: %s", loadDiags.Err())
+		}
+
+		b, bDiags := m.prepareBackend(mod)
+		if bDiags.HasErrors() {
+			t.Fatal("unexpected error: ", bDiags.Err())
+		}
+
+		if _, ok := b.(*local.Local); !ok {
+			t.Fatal("expected returned operations backend to be a Local backend")
+		}
+	})
+
+	t.Run("it returns a local backend when there is empty configuration", func(t *testing.T) {
+		m := testMetaBackend(t, nil)
+		emptyConfig := configs.NewEmptyConfig()
+
+		b, bDiags := m.prepareBackend(emptyConfig.Module)
+		if bDiags.HasErrors() {
+			t.Fatal("unexpected error: ", bDiags.Err())
+		}
+
+		if _, ok := b.(*local.Local); !ok {
+			t.Fatal("expected returned operations backend to be a Local backend")
+		}
+	})
+
+	t.Run("it returns a state_store from state_store config", func(t *testing.T) {
+		// Create a temporary working directory with backend configuration in
+		td := t.TempDir()
+		testCopyDir(t, testFixturePath("state-store-unchanged"), td)
+		t.Chdir(td)
+
+		m := testMetaBackend(t, nil)
+		m.AllowExperimentalFeatures = true
+		mock := testStateStoreMock(t)
+		m.testingOverrides = &testingOverrides{
+			Providers: map[addrs.Provider]providers.Factory{
+				addrs.NewDefaultProvider("test"): providers.FactoryFixed(mock),
+			},
+		}
+
+		// Get the backend config
+		mod, loadDiags := m.loadSingleModule(td)
+		if loadDiags.HasErrors() {
+			t.Fatalf("unexpected error when loading test config: %s", loadDiags.Err())
+		}
+
+		_, bDiags := m.prepareBackend(mod)
+		if !bDiags.HasErrors() {
+			// TODO(SarahFrench/radeksimko): In future, we don't expect an error here!
+			t.Fatal("expected errors while state_store, due to incomplete implementation")
+		}
+		if !strings.Contains(bDiags.Err().Error(), "Changing a state store configuration is not implemented yet") {
+			t.Fatal("unexpected error: ", bDiags.Err())
+		}
+
+		// TODO(SarahFrench/radeksimko): Make assertion about returned operations backend.
+	})
+}
+
 func testMetaBackend(t *testing.T, args []string) *Meta {
 	var m Meta
 	m.Ui = new(cli.MockUi)

internal/command/testdata/state-store-unchanged/.terraform/terraform.tfstate

@@ -0,0 +1,18 @@
+{
+    "version": 3,
+    "serial": 0,
+    "lineage": "666f9301-7e65-4b19-ae23-71184bb19b03",
+    "state_store": {
+        "type": "test_store",
+        "config": {
+            "value": "value"
+        },
+        "provider": {
+            "version": "1.2.3",
+            "source": "registry.terraform.io/hashicorp/test",
+            "config": {},
+            "hash": 12345
+        },
+        "hash": 12345
+    }
+}

internal/command/testdata/state-store-unchanged/main.tf

@@ -0,0 +1,13 @@
+terraform {
+  required_providers {
+    test = {
+      source  = "hashicorp/test"
+      version = "1.2.3"
+    }
+  }
+  state_store "test_store" {
+    provider "test" {}
+
+    value = "value" # matches backend state file
+  }
+}