Adding RefreshState test step

.changelog/1070.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+helper/resource: Add RefreshState to allow testing of refresh in isolation
+```

helper/resource/testing.go

@@ -570,6 +570,14 @@ type TestStep struct {
 	// at the end of the test step that is verifying import behavior.
 	ImportStatePersist bool
 
+	//---------------------------------------------------------------
+	// RefreshState testing
+	//---------------------------------------------------------------
+
+	// RefreshState, if true, will test the functionality of `terraform
+	// refresh` by refreshing the state.
+	RefreshState bool
+
 	// ProviderFactories can be specified for the providers that are valid for
 	// this TestStep. When providers are specified at the TestStep level, all
 	// TestStep within a TestCase must declare providers.

helper/resource/testing_new.go

@@ -241,6 +241,45 @@ func runNewTest(ctx context.Context, t testing.T, c TestCase, helper *plugintest
 			continue
 		}
 
+		if step.RefreshState {
+			logging.HelperResourceTrace(ctx, "TestStep is RefreshState mode")
+
+			err := testStepNewRefreshState(ctx, t, wd, step, appliedCfg, providers)
+			if step.ExpectError != nil {
+				logging.HelperResourceDebug(ctx, "Checking TestStep ExpectError")
+				if err == nil {
+					logging.HelperResourceError(ctx,
+						"Error running refresh: expected an error but got none",
+					)
+					t.Fatalf("Step %d/%d error running refresh: expected an error but got none", stepNumber, len(c.Steps))
+				}
+				if !step.ExpectError.MatchString(err.Error()) {
+					logging.HelperResourceError(ctx,
+						fmt.Sprintf("Error running refresh: expected an error with pattern (%s)", step.ExpectError.String()),
+						map[string]interface{}{logging.KeyError: err},
+					)
+					t.Fatalf("Step %d/%d error running refresh, expected an error with pattern (%s), no match on: %s", stepNumber, len(c.Steps), step.ExpectError.String(), err)
+				}
+			} else {
+				if err != nil && c.ErrorCheck != nil {
+					logging.HelperResourceDebug(ctx, "Calling TestCase ErrorCheck")
+					err = c.ErrorCheck(err)
+					logging.HelperResourceDebug(ctx, "Called TestCase ErrorCheck")
+				}
+				if err != nil {
+					logging.HelperResourceError(ctx,
+						"Error running refresh",
+						map[string]interface{}{logging.KeyError: err},
+					)
+					t.Fatalf("Step %d/%d error running refresh: %s", stepNumber, len(c.Steps), err)
+				}
+			}
+
+			logging.HelperResourceDebug(ctx, "Finished TestStep")
+
+			continue
+		}
+
 		if step.Config != "" {
 			logging.HelperResourceTrace(ctx, "TestStep is Config mode")
 

helper/resource/testing_new_refresh_state.go

@@ -0,0 +1,86 @@
+package resource
+
+import (
+	"context"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/mitchellh/go-testing-interface"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/internal/logging"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/internal/plugintest"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
+)
+
+func testStepNewRefreshState(ctx context.Context, t testing.T, wd *plugintest.WorkingDir, step TestStep, cfg string, providers *providerFactories) error {
+	t.Helper()
+
+	spewConf := spew.NewDefaultConfig()
+	spewConf.SortKeys = true
+
+	var err error
+	err = runProviderCommand(ctx, t, func() error {
+		_, err = getState(ctx, t, wd)
+		if err != nil {
+			return err
+		}
+		return nil
+	}, wd, providers)
+	if err != nil {
+		t.Fatalf("Error getting state: %s", err)
+	}
+
+	if step.Config == "" {
+		logging.HelperResourceTrace(ctx, "Using prior TestStep Config for refresh")
+
+		step.Config = cfg
+		if step.Config == "" {
+			t.Fatal("Cannot refresh state with no specified config")
+		}
+	}
+
+	err = wd.SetConfig(ctx, step.Config)
+	if err != nil {
+		t.Fatalf("Error setting test config: %s", err)
+	}
+
+	logging.HelperResourceDebug(ctx, "Running Terraform CLI init and refresh")
+
+	err = runProviderCommand(ctx, t, func() error {
+		return wd.Init(ctx)
+	}, wd, providers)
+	if err != nil {
+		t.Fatalf("Error running init: %s", err)
+	}
+
+	err = runProviderCommand(ctx, t, func() error {
+		return wd.Refresh(ctx)
+	}, wd, providers)
+	if err != nil {
+		return err
+	}
+
+	var refreshState *terraform.State
+	err = runProviderCommand(ctx, t, func() error {
+		refreshState, err = getState(ctx, t, wd)
+		if err != nil {
+			return err
+		}
+		return nil
+	}, wd, providers)
+	if err != nil {
+		t.Fatalf("Error getting state: %s", err)
+	}
+
+	// Go through the refreshed state and verify
+	if step.Check != nil {
+		logging.HelperResourceDebug(ctx, "Calling TestStep Check for RefreshState")
+
+		if err := step.Check(refreshState); err != nil {
+			t.Fatal(err)
+		}
+
+		logging.HelperResourceDebug(ctx, "Called TestStep Check for RefreshState")
+	}
+
+	return nil
+}

helper/resource/teststep_providers_test.go

@@ -1574,6 +1574,67 @@ func TestTest_TestStep_ProviderFactories_Import_External_WithoutPersistNonMatch(
 	})
 }
 
+func TestTest_TestStep_ProviderFactories_Refresh_Inline(t *testing.T) {
+	t.Parallel()
+
+	Test(t, TestCase{
+		ProviderFactories: map[string]func() (*schema.Provider, error){
+			"random": func() (*schema.Provider, error) { //nolint:unparam // required signature
+				return &schema.Provider{
+					ResourcesMap: map[string]*schema.Resource{
+						"random_password": {
+							CreateContext: func(ctx context.Context, d *schema.ResourceData, i interface{}) diag.Diagnostics {
+								d.SetId("id")
+								err := d.Set("min_special", 10)
+								if err != nil {
+									panic(err)
+								}
+								return nil
+							},
+							DeleteContext: func(_ context.Context, _ *schema.ResourceData, _ interface{}) diag.Diagnostics {
+								return nil
+							},
+							ReadContext: func(_ context.Context, d *schema.ResourceData, _ interface{}) diag.Diagnostics {
+								err := d.Set("min_special", 2)
+								if err != nil {
+									panic(err)
+								}
+								return nil
+							},
+							Schema: map[string]*schema.Schema{
+								"min_special": {
+									Computed: true,
+									Type:     schema.TypeInt,
+								},
+
+								"id": {
+									Computed: true,
+									Type:     schema.TypeString,
+								},
+							},
+						},
+					},
+				}, nil
+			},
+		},
+		Steps: []TestStep{
+			{
+				Config: `resource "random_password" "test" { }`,
+				Check:  TestCheckResourceAttr("random_password.test", "min_special", "10"),
+			},
+			{
+				Config:       `resource "random_password" "test" { }`,
+				RefreshState: true,
+				Check:        TestCheckResourceAttr("random_password.test", "min_special", "2"),
+			},
+			{
+				Config: `resource "random_password" "test" { }`,
+				Check:  TestCheckResourceAttr("random_password.test", "min_special", "2"),
+			},
+		},
+	})
+}
+
 func composeImportStateCheck(fs ...ImportStateCheckFunc) ImportStateCheckFunc {
 	return func(s []*terraform.InstanceState) error {
 		for i, f := range fs {