feat: Add Validate method for asserting that a plan's description of a backend or state store is complete

The alternative approach would be to change the existing `Backend` field in the `Plan` struct to be a pointer. I'm open to either option, but the approach of using an `Empty` method matches existing work in the `workdir` package when inspecting the backend state file, and that seems a similar use-case to inspecting the plan file.

Author: SarahFrench

internal/plans/plan.go

@@ -4,6 +4,8 @@
 package plans
 
 import (
+	"errors"
+	"fmt"
 	"sort"
 	"time"
 
@@ -256,6 +258,22 @@ func NewBackend(typeName string, config cty.Value, configSchema *configschema.Bl
 	}, nil
 }
 
+func (b *Backend) Validate() error {
+	if b == nil {
+		return errors.New("plan contains a nil Backend")
+	}
+	if b.Type == "" {
+		return fmt.Errorf("plan's description of a backend has an unset Type: %#v", b)
+	}
+	if b.Workspace == "" {
+		return fmt.Errorf("plan's description of a backend has the Workspace unset: %#v", b)
+	}
+	if len(b.Config) == 0 {
+		return fmt.Errorf("plan's description of a backend includes no Config: %#v", b)
+	}
+	return nil
+}
+
 // StateStore represents the state store-related configuration and other data as it
 // existed when a plan was created.
 type StateStore struct {
@@ -264,8 +282,8 @@ type StateStore struct {
 
 	Provider *Provider
 
-	// Config is the configuration of the state store, whose schema is obtained
-	// from the host provider's GetProviderSchema response.
+	// Config is the configuration of the state store, excluding the nested provider block.
+	// The schema is determined by the state store's type and data received via GetProviderSchema RPC.
 	Config DynamicValue
 
 	// Workspace is the name of the workspace that was active when the plan
@@ -277,15 +295,50 @@ type StateStore struct {
 	Workspace string
 }
 
+func (s *StateStore) Validate() error {
+	if s == nil {
+		return errors.New("plan contains a nil StateStore")
+	}
+	if s.Type == "" {
+		return fmt.Errorf("plan's description of a state store has an unset Type: %#v", s)
+	}
+	if len(s.Config) == 0 {
+		return fmt.Errorf("plan's description of a state store includes no Config: %#v", s)
+	}
+	if err := s.Provider.Validate(); err != nil {
+		return err
+	}
+	if s.Workspace == "" {
+		return fmt.Errorf("plan's description of a state store has an unset Workspace: %#v", s)
+	}
+	return nil
+}
+
 type Provider struct {
 	Version *version.Version // The specific provider version used for the state store. Should be set using a getproviders.Version, etc.
 	Source  *tfaddr.Provider // The FQN/fully-qualified name of the provider.
 
-	// Config is the configuration of the state store, whose schema is obtained
-	// from the host provider's GetProviderSchema response.
+	// Config is the configuration of the provider block nested within state_store.
+	// The schema is determined by data received via GetProviderSchema RPC.
 	Config DynamicValue
 }
 
+func (p *Provider) Validate() error {
+	if p == nil {
+		return errors.New("plan's description of a state store contains a nil Provider")
+	}
+	if p.Version == nil {
+		return fmt.Errorf("plan's description of a state store contains a nil provider Version: %#v", p)
+	}
+	if p.Source == nil {
+		return fmt.Errorf("plan's description of a state store contains a nil provider Source: %#v", p)
+	}
+	if len(p.Config) == 0 {
+		return fmt.Errorf("plan's description of a state store includes no provider Config: %#v", p)
+	}
+	return nil
+}
+
 func NewStateStore(typeName string, ver *version.Version, source *tfaddr.Provider, storeConfig cty.Value, storeSchema *configschema.Block, providerConfig cty.Value, providerSchema *configschema.Block, workspaceName string) (*StateStore, error) {
 	sdv, err := NewDynamicValue(storeConfig, storeSchema.ImpliedType())
 	if err != nil {

internal/plans/plan_test.go

@@ -7,9 +7,11 @@ import (
 	"testing"
 
 	"github.com/go-test/deep"
+	"github.com/zclconf/go-cty/cty"
 
+	version "github.com/hashicorp/go-version"
 	"github.com/hashicorp/terraform/internal/addrs"
-	"github.com/zclconf/go-cty/cty"
+	"github.com/hashicorp/terraform/internal/configs/configschema"
 )
 
 func TestProviderAddrs(t *testing.T) {
@@ -105,6 +107,188 @@ func TestProviderAddrs(t *testing.T) {
 	}
 }
 
+func TestBackend_Validate(t *testing.T) {
+
+	typeName := "foobar"
+	workspace := "default"
+	config := cty.ObjectVal(map[string]cty.Value{
+		"bool": cty.BoolVal(true),
+	})
+	schema := &configschema.Block{
+		Attributes: map[string]*configschema.Attribute{
+			"bool": {
+				Type: cty.Bool,
+			},
+		},
+	}
+
+	// Not-empty cases
+	t.Run("backend is not valid if all values are set", func(t *testing.T) {
+		b, err := NewBackend(typeName, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := b.Validate(); err != nil {
+			t.Fatalf("expected the Backend to be valid, given all input values were provided: %s", err)
+		}
+	})
+	t.Run("backend is not empty if the schema contains no attributes or blocks", func(t *testing.T) {
+		emptyConfig := cty.ObjectVal(map[string]cty.Value{})
+		emptySchema := &configschema.Block{
+			Attributes: map[string]*configschema.Attribute{
+				// No attributes
+			},
+		}
+		b, err := NewBackend(typeName, emptyConfig, emptySchema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := b.Validate(); err != nil {
+			t.Fatalf("expected the Backend to be valid, as empty schemas should be tolerated: %s", err)
+		}
+	})
+
+	// Empty cases
+	t.Run("backend is empty if type name is missing", func(t *testing.T) {
+		b, err := NewBackend("", config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := b.Validate(); err == nil {
+			t.Fatalf("expected the Backend to be invalid, given the type being unset: %#v", b)
+		}
+	})
+	t.Run("backend is empty if workspace name is missing", func(t *testing.T) {
+		b, err := NewBackend(typeName, config, schema, "")
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := b.Validate(); err == nil {
+			t.Fatalf("expected the Backend to be invalid, given the type being unset: %#v", b)
+		}
+	})
+}
+
+func TestStateStore_Validate(t *testing.T) {
+	typeName := "test_store"
+	providerVersion := version.Must(version.NewSemver("1.2.3"))
+	source := addrs.MustParseProviderSourceString("hashicorp/test")
+	workspace := "default"
+	config := cty.ObjectVal(map[string]cty.Value{
+		"bool": cty.BoolVal(true),
+	})
+	schema := &configschema.Block{
+		Attributes: map[string]*configschema.Attribute{
+			"bool": {
+				Type: cty.Bool,
+			},
+		},
+	}
+
+	// Not-empty cases
+	t.Run("state store is not empty if all values are set", func(t *testing.T) {
+		s, err := NewStateStore(typeName, providerVersion, &source, config, schema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err != nil {
+			t.Fatalf("expected the StateStore to be valid, given all input values were provided: %s", err)
+		}
+	})
+	t.Run("state store is not empty if the state store config is present but contains all null values", func(t *testing.T) {
+		nullConfig := cty.ObjectVal(map[string]cty.Value{
+			"bool": cty.NullVal(cty.Bool),
+		})
+		s, err := NewStateStore(typeName, providerVersion, &source, nullConfig, schema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err != nil {
+			t.Fatalf("expected the StateStore to be valid, despite the state store config containing only null values: %s", err)
+		}
+	})
+	t.Run("state store is not empty if the provider config is present but contains all null values", func(t *testing.T) {
+		nullConfig := cty.ObjectVal(map[string]cty.Value{
+			"bool": cty.NullVal(cty.Bool),
+		})
+		s, err := NewStateStore(typeName, providerVersion, &source, nullConfig, schema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err != nil {
+			t.Fatalf("expected the StateStore to be valid, despite the provider config containing only null values:  %s", err)
+		}
+	})
+	t.Run("state store is not incorrectly identified as empty if the state store's schema contains no attributes or blocks", func(t *testing.T) {
+		emptyConfig := cty.ObjectVal(map[string]cty.Value{})
+		emptySchema := &configschema.Block{
+			Attributes: map[string]*configschema.Attribute{
+				// No attributes
+			},
+		}
+		s, err := NewStateStore(typeName, providerVersion, &source, emptyConfig, emptySchema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err != nil {
+			t.Fatalf("expected the StateStore to be valid, as empty schemas should be tolerated: %s", err)
+		}
+	})
+	t.Run("state store is not incorrectly identified as empty if the provider's schema contains no attributes or blocks", func(t *testing.T) {
+		emptyConfig := cty.ObjectVal(map[string]cty.Value{})
+		emptySchema := &configschema.Block{
+			Attributes: map[string]*configschema.Attribute{
+				// No attributes
+			},
+		}
+		s, err := NewStateStore(typeName, providerVersion, &source, config, schema, emptyConfig, emptySchema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err != nil {
+			t.Fatalf("expected the StateStore to be valid, as empty schemas should be tolerated: %s", err)
+		}
+	})
+
+	// Empty cases
+	t.Run("state store is empty if the type is missing", func(t *testing.T) {
+		s, err := NewStateStore("", providerVersion, &source, config, schema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err == nil {
+			t.Fatalf("expected the StateStore to be invalid,  given the type name is missing: %s", err)
+		}
+	})
+	t.Run("state store is empty if the provider version is missing", func(t *testing.T) {
+		s, err := NewStateStore(typeName, nil, &source, config, schema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err == nil {
+			t.Fatalf("expected the StateStore to be invalid, given the version is missing: %s", err)
+		}
+	})
+	t.Run("state store is empty if the provider source is missing", func(t *testing.T) {
+		s, err := NewStateStore(typeName, providerVersion, nil, config, schema, config, schema, workspace)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err == nil {
+			t.Fatalf("expected the StateStore to be invalid, given the version is missing: %s", err)
+		}
+	})
+	t.Run("state store is empty if the workspace name is missing", func(t *testing.T) {
+		s, err := NewStateStore(typeName, providerVersion, &source, cty.NilVal, schema, config, schema, "")
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if err := s.Validate(); err == nil {
+			t.Fatalf("expected the StateStore to be invalid, given the workspace name is missing: %s", err)
+		}
+	})
+}
+
 // Module outputs should not effect the result of Empty
 func TestModuleOutputChangesEmpty(t *testing.T) {
 	changes := &ChangesSrc{