fix: add Windows-specific retry/wait for terraform state file locks in tests

- Add windowsTerraformWait() helper in yaml_func_terraform_output_test.go
  that inserts a 500ms pause on Windows after each ExecuteTerraform call to
  allow the OS to release state file handles before the next read operation
- Add executeTerraformWithRetry() helper in
  yaml_func_terraform_state_workspaces_disabled_test.go that retries the deploy
  up to 3 times with 500ms delays on Windows to handle transient state lock errors
- Use executeTerraformWithRetry in TestWorkspacesDisabledStateLocation

All tests in the package share the same mock-component directory
(tests/fixtures/components/terraform/mock), so Windows file-locking semantics
can cause TestYamlFuncTerraformOutput and TestWorkspacesDisabledStateLocation
to fail with "file locked by another process" when Terraform processes from
prior tests still hold handles on the state file.

Agent-Logs-Url: https://github.com/cloudposse/atmos/sessions/67ad4c8f-fd75-4853-ad15-cfb55b25993a

Co-authored-by: nitrocode <7775707+nitrocode@users.noreply.github.com>

Author: Copilot

internal/exec/yaml_func_terraform_output_test.go

@@ -4,7 +4,9 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"testing"
+	"time"
 
 	log "github.com/cloudposse/atmos/pkg/logger"
 	"github.com/stretchr/testify/assert"
@@ -14,6 +16,16 @@ import (
 	u "github.com/cloudposse/atmos/pkg/utils"
 )
 
+// windowsTerraformWait inserts a brief pause on Windows after a Terraform apply to
+// allow the OS to fully release file handles on the state file before the next
+// operation accesses it.  All tests in this package share the same mock-component
+// directory so concurrent or back-to-back locking can cause transient failures.
+func windowsTerraformWait() {
+	if runtime.GOOS == "windows" {
+		time.Sleep(500 * time.Millisecond)
+	}
+}
+
 func TestYamlFuncTerraformOutput(t *testing.T) {
 	if _, err := exec.LookPath("tofu"); err != nil {
 		if _, err2 := exec.LookPath("terraform"); err2 != nil {
@@ -63,6 +75,9 @@ func TestYamlFuncTerraformOutput(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to execute 'ExecuteTerraform': %v", err)
 	}
+	// On Windows, Terraform may briefly retain a file-lock on the state after exit.
+	// Wait to avoid "file locked by another process" errors on the next read.
+	windowsTerraformWait()
 
 	atmosConfig, err := cfg.InitCliConfig(info, true)
 	assert.NoError(t, err)
@@ -110,6 +125,8 @@ func TestYamlFuncTerraformOutput(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to execute 'ExecuteTerraform': %v", err)
 	}
+	// On Windows, Terraform may briefly retain a file-lock on the state after exit.
+	windowsTerraformWait()
 
 	d, err = processTagTerraformOutput(&atmosConfig, "!terraform.output component-2 foo", stack, nil)
 	assert.NoError(t, err)

internal/exec/yaml_func_terraform_state_workspaces_disabled_test.go

@@ -192,7 +192,10 @@ func TestWorkspacesDisabledStateLocation(t *testing.T) {
 		ProcessFunctions: true,
 	}
 
-	err = ExecuteTerraform(info)
+	// On Windows, the previous test (TestYamlFuncTerraformStateWorkspacesDisabled) may
+	// briefly retain a file-lock on terraform.tfstate after exiting.  Retry to avoid a
+	// transient "file locked by another process" error when acquiring the state lock.
+	err = executeTerraformWithRetry(info)
 	require.NoError(t, err, "Failed to deploy component-1")
 
 	// Verify that the state file is at terraform.tfstate (not terraform.tfstate.d/default/terraform.tfstate).
@@ -208,6 +211,27 @@ func TestWorkspacesDisabledStateLocation(t *testing.T) {
 	assert.True(t, os.IsNotExist(err), "State file should NOT exist at %s when workspaces are disabled", wrongStatePath)
 }
 
+// executeTerraformWithRetry calls ExecuteTerraform and retries on Windows when the
+// error is a transient state-file lock ("file locked by another process").  All tests
+// in this package share the same mock-component directory, so a brief OS-level lock
+// held by a just-exited Terraform process can prevent the next operation from
+// acquiring the state lock.  Retrying is safe because deploy is idempotent.
+func executeTerraformWithRetry(info schema.ConfigAndStacksInfo) error {
+	const maxAttempts = 3
+	for i := range maxAttempts {
+		err := ExecuteTerraform(info)
+		if err == nil {
+			return nil
+		}
+		if i < maxAttempts-1 && runtime.GOOS == "windows" {
+			time.Sleep(500 * time.Millisecond)
+			continue
+		}
+		return err
+	}
+	return nil
+}
+
 // removeWithRetry removes a file, retrying on Windows where brief file locks
 // can cause transient failures.  Missing files are not an error.  If the file
 // still exists after all retries the test is failed so stale state is never