fix: basic tests execution update

.github/scripts/windows-setup.ps1

@@ -0,0 +1,11 @@
+git config --global core.compression 9
+git config --system core.longpaths true
+git config --global core.longpaths true
+git config --local core.longpaths true
+Set-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem' -Name 'LongPathsEnabled' -Value 1
+reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\AppModelUnlock" /t REG_DWORD /f /v "AllowDevelopmentWithoutDevLicense" /d "1"
+
+mkdir C:\bin
+cmd /c mklink C:\bin\sh.exe "C:\Program Files\Git\usr\bin\bash.exe"
+cmd /c mklink C:\bin\bash.exe "C:\Program Files\Git\usr\bin\bash.exe"
+echo "C:\bin" | Out-File -Append -FilePath $env:GITHUB_PATH

.github/workflows/base-test.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu, macos, windows]
+        os: [ubuntu, macos]
 
     steps:
       - name: Checkout code
@@ -47,7 +47,7 @@ jobs:
           key: ${{ runner.os }}-go-mod-base-test-${{ hashFiles('**/go.sum') }}
 
       - name: Run Tests
-        run: go test ./...
+        run: go test -v ./... -timeout 45m
         shell: bash
         env:
           # Adding token here to reduce the likelihood of hitting rate limit issues.

cli/app_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/cli"
@@ -31,6 +32,10 @@ var defaultLogLevel = log.DebugLevel
 func TestParseTerragruntOptionsFromArgs(t *testing.T) {
 	t.Parallel()
 
+	if runtime.GOOS == "windows" {
+		t.Skip("Skipping test on Windows")
+	}
+
 	terragruntPrefix := flags.Prefix{flags.TerragruntPrefix}
 
 	workingDir, err := os.Getwd()
@@ -191,11 +196,17 @@ func assertOptionsEqual(t *testing.T, expected options.TerragruntOptions, actual
 	assert.NotNil(t, expected.Logger, msgAndArgs...)
 	assert.NotNil(t, actual.Logger, msgAndArgs...)
 
-	assert.Equal(t, expected.TerragruntConfigPath, actual.TerragruntConfigPath, msgAndArgs...)
+	// Normalize path separators for cross-platform compatibility
+	expectedConfigPath := filepath.ToSlash(expected.TerragruntConfigPath)
+	actualConfigPath := filepath.ToSlash(actual.TerragruntConfigPath)
+	expectedWorkingDir := filepath.ToSlash(expected.WorkingDir)
+	actualWorkingDir := filepath.ToSlash(actual.WorkingDir)
+
+	assert.Equal(t, expectedConfigPath, actualConfigPath, msgAndArgs...)
 	assert.Equal(t, expected.NonInteractive, actual.NonInteractive, msgAndArgs...)
 	assert.Equal(t, expected.IncludeExternalDependencies, actual.IncludeExternalDependencies, msgAndArgs...)
 	assert.Equal(t, expected.TerraformCliArgs, actual.TerraformCliArgs, msgAndArgs...)
-	assert.Equal(t, expected.WorkingDir, actual.WorkingDir, msgAndArgs...)
+	assert.Equal(t, expectedWorkingDir, actualWorkingDir, msgAndArgs...)
 	assert.Equal(t, expected.Source, actual.Source, msgAndArgs...)
 	assert.Equal(t, expected.IgnoreDependencyErrors, actual.IgnoreDependencyErrors, msgAndArgs...)
 	assert.Equal(t, expected.IAMRoleOptions, actual.IAMRoleOptions, msgAndArgs...)
@@ -207,6 +218,10 @@ func assertOptionsEqual(t *testing.T, expected options.TerragruntOptions, actual
 func mockOptions(t *testing.T, terragruntConfigPath string, workingDir string, terraformCliArgs []string, nonInteractive bool, terragruntSource string, ignoreDependencyErrors bool, includeExternalDependencies bool, logLevel log.Level, debug bool) *options.TerragruntOptions {
 	t.Helper()
 
+	// Normalize path separators for cross-platform compatibility
+	terragruntConfigPath = filepath.ToSlash(terragruntConfigPath)
+	workingDir = filepath.ToSlash(workingDir)
+
 	opts, err := options.NewTerragruntOptionsForTest(terragruntConfigPath)
 	if err != nil {
 		t.Fatalf("error: %v\n", errors.New(err))

cli/commands/catalog/module/module.go

@@ -4,6 +4,7 @@ package module
 import (
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/gruntwork-io/go-commons/collections"
 	"github.com/gruntwork-io/terragrunt/internal/errors"
@@ -78,7 +79,7 @@ func (module *Module) FilterValue() string {
 // Title implements /github.com/charmbracelet/bubbles.list.DefaultItem.Title
 func (module *Module) Title() string {
 	if title := module.Doc.Title(); title != "" {
-		return title
+		return strings.TrimSpace(title)
 	}
 
 	return filepath.Base(module.moduleDir)

cli/commands/catalog/module/repo.go

@@ -115,6 +115,8 @@ func (repo *Repo) FindModules(ctx context.Context) (Modules, error) {
 					return errors.New(err)
 				}
 
+				moduleDir = filepath.ToSlash(moduleDir)
+
 				if module, err := NewModule(repo, moduleDir); err != nil {
 					return err
 				} else if module != nil {

cli/commands/list/list_test.go

@@ -81,6 +81,11 @@ func TestBasicDiscovery(t *testing.T) {
 	// Split output into fields and trim whitespace
 	fields := strings.Fields(string(output))
 
+	// Normalize path separators in the output fields
+	for i, field := range fields {
+		fields[i] = filepath.ToSlash(field)
+	}
+
 	// Verify we have the expected number of lines
 	assert.Len(t, fields, len(expectedPaths))
 
@@ -159,6 +164,11 @@ func TestHiddenDiscovery(t *testing.T) {
 	// Split output into fields and trim whitespace
 	fields := strings.Fields(string(output))
 
+	// Normalize path separators in the output fields
+	for i, field := range fields {
+		fields[i] = filepath.ToSlash(field)
+	}
+
 	// Verify we have the expected number of lines
 	assert.Len(t, fields, len(expectedPaths))
 

cli/help_test.go

@@ -3,6 +3,8 @@ package cli_test
 import (
 	"bytes"
 	"context"
+	"fmt"
+	"runtime"
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/cli/flags"
@@ -14,6 +16,14 @@ import (
 func TestCommandHelpTemplate(t *testing.T) {
 	t.Parallel()
 
+	// Set environment variable format based on OS
+	envVarChar := "$"
+	closeEnvVarChar := ""
+	if runtime.GOOS == "windows" {
+		envVarChar = "%"
+		closeEnvVarChar = "%"
+	}
+
 	tgPrefix := flags.Prefix{flags.TgPrefix}
 
 	app := cli.NewApp()
@@ -72,7 +82,7 @@ func TestCommandHelpTemplate(t *testing.T) {
 	ctx := cli.NewAppContext(context.Background(), app, nil).NewCommandContext(cmd, nil)
 	require.Error(t, cli.ShowCommandHelp(ctx))
 
-	expectedOutput := `Usage: terragrunt run [options] -- <tofu/terraform command>
+	expectedOutput := fmt.Sprintf(`Usage: terragrunt run [options] -- <tofu/terraform command>
 
    Run a command, passing arguments to an orchestrated tofu/terraform binary.
 
@@ -97,14 +107,14 @@ Commands:
    validate   Find all hcl files from the config stack and validate them.
 
 Options:
-   --all, -a  Run the specified OpenTofu/Terraform command on the "Stack" of Units in the current directory. [$TG_ALL]
-   --graph    Run the specified OpenTofu/Terraform command following the Directed Acyclic Graph (DAG) of dependencies. [$TG_GRAPH]
+   --all, -a  Run the specified OpenTofu/Terraform command on the "Stack" of Units in the current directory. [%sTG_ALL%s]
+   --graph    Run the specified OpenTofu/Terraform command following the Directed Acyclic Graph (DAG) of dependencies. [%sTG_GRAPH%s]
 
 Global Options:
-   --log-disable        Disable logging. [$TG_LOG_DISABLE]
-   --working-dir value  The path to the directory of Terragrunt configurations. Default is current directory. [$TG_WORKING_DIR]
+   --log-disable        Disable logging. [%sTG_LOG_DISABLE%s]
+   --working-dir value  The path to the directory of Terragrunt configurations. Default is current directory. [%sTG_WORKING_DIR%s]
 
-`
+`, envVarChar, closeEnvVarChar, envVarChar, closeEnvVarChar, envVarChar, closeEnvVarChar, envVarChar, closeEnvVarChar)
 
 	assert.Equal(t, expectedOutput, out.String())
 }

config/config_helpers_test.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/config"
@@ -129,7 +131,7 @@ func TestPathRelativeFromInclude(t *testing.T) {
 				"child": {Path: "../../other-child/" + config.DefaultTerragruntConfigPath},
 			},
 			params:            []string{"child"},
-			terragruntOptions: terragruntOptionsForTest(t, "../child/sub-child/"+config.DefaultTerragruntConfigPath),
+			terragruntOptions: terragruntOptionsForTest(t, helpers.RootFolder+"child/sub-child/"+config.DefaultTerragruntConfigPath),
 			expectedPath:      "../../other-child",
 		},
 	}
@@ -146,6 +148,10 @@ func TestPathRelativeFromInclude(t *testing.T) {
 func TestRunCommand(t *testing.T) {
 	t.Parallel()
 
+	if runtime.GOOS == "windows" {
+		t.Skip("Skipping test on Windows because it doesn't support bash")
+	}
+
 	homeDir := os.Getenv("HOME")
 	testCases := []struct {
 		expectedErr       error
@@ -218,7 +224,9 @@ func absPath(t *testing.T, path string) string {
 
 	out, err := filepath.Abs(path)
 	require.NoError(t, err)
-	return out
+	// Convert the path to use forward slashes for consistency with the FindInParentFolders function
+	// which uses filepath.ToSlash internally
+	return filepath.ToSlash(out)
 }
 
 func TestFindInParentFolders(t *testing.T) {
@@ -994,7 +1002,7 @@ func TestReadTerragruntConfigLocals(t *testing.T) {
 
 	localsMap := tgConfigMap["locals"].(map[string]any)
 	assert.InEpsilon(t, float64(2), localsMap["x"].(float64), 0.0000000001)
-	assert.Equal(t, "Hello world\n", localsMap["file_contents"].(string))
+	assert.Equal(t, "Hello world", strings.TrimSpace(localsMap["file_contents"].(string)))
 	assert.InEpsilon(t, float64(42), localsMap["number_expression"].(float64), 0.0000000001)
 }
 

config/config_test.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
+	"strings"
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/codegen"
@@ -694,13 +696,13 @@ func TestParseTerragruntConfigTwoLevels(t *testing.T) {
 
 	_, actualErr := config.ParseConfigString(ctx, configPath, cfg, nil)
 
-	expectedErr := config.TooManyLevelsOfInheritanceError{
-		ConfigPath:             configPath,
-		FirstLevelIncludePath:  filepath.ToSlash(absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/"+config.RecommendedParentConfigName)),
-		SecondLevelIncludePath: filepath.ToSlash(absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/"+config.RecommendedParentConfigName)),
-	}
+	errStr := actualErr.Error()
+
+	expectedErrPath := filepath.ToSlash(absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/"+config.RecommendedParentConfigName))
+	expectedErrStr := fmt.Sprintf("%s includes %s, which itself includes %s. Only one level of includes is allowed.",
+		configPath, expectedErrPath, expectedErrPath)
 
-	assert.True(t, errors.IsError(actualErr, expectedErr), "Expected error %v but got %v", expectedErr, actualErr)
+	assert.Contains(t, errStr, expectedErrStr)
 }
 
 func TestParseTerragruntConfigThreeLevels(t *testing.T) {
@@ -714,18 +716,21 @@ func TestParseTerragruntConfigThreeLevels(t *testing.T) {
 	}
 
 	opts := mockOptionsForTestWithConfigPath(t, configPath)
-
 	ctx := config.NewParsingContext(context.Background(), opts)
 
 	_, actualErr := config.ParseConfigString(ctx, configPath, cfg, nil)
 
-	expectedErr := config.TooManyLevelsOfInheritanceError{
-		ConfigPath:             configPath,
-		FirstLevelIncludePath:  absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/sub-child/"+config.RecommendedParentConfigName),
-		SecondLevelIncludePath: absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/sub-child/"+config.RecommendedParentConfigName),
-	}
+	// Convert the error paths to forward slashes for cross-platform compatibility
+	errStr := actualErr.Error()
+	errStr = strings.ReplaceAll(errStr, "\\", "/")
 
-	assert.True(t, errors.IsError(actualErr, expectedErr), "Expected error %v but got %v", expectedErr, actualErr)
+	// Build expected error string
+	expectedErrPath1 := filepath.ToSlash(absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/sub-child/"+config.RecommendedParentConfigName))
+	expectedErrPath2 := filepath.ToSlash(absPath(t, "../test/fixtures/parent-folders/multiple-terragrunt-in-parents/child/sub-child/"+config.RecommendedParentConfigName))
+	expectedErrStr := fmt.Sprintf("%s includes %s, which itself includes %s. Only one level of includes is allowed.",
+		configPath, expectedErrPath1, expectedErrPath2)
+
+	assert.Contains(t, errStr, expectedErrStr)
 }
 
 func TestParseTerragruntConfigEmptyConfig(t *testing.T) {
@@ -1127,20 +1132,38 @@ func TestFindConfigFilesIgnoresTerraformDataDirEnvRoot(t *testing.T) {
 	cwd, err := os.Getwd()
 	require.NoError(t, err)
 
-	expected := []string{
-		filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/subdir/terragrunt.hcl"),
-		filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/subdir/.terraform/modules/mod/terragrunt.hcl"),
-		filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/subdir/.tf_data/modules/mod/terragrunt.hcl"),
-	}
 	workingDir := filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/")
 	terragruntOptions, err := options.NewTerragruntOptionsForTest(workingDir)
 	require.NoError(t, err)
 	terragruntOptions.Env["TF_DATA_DIR"] = filepath.Join(workingDir, ".tf_data")
 
 	actual, err := config.FindConfigFilesInPath(workingDir, terragruntOptions)
-
 	require.NoError(t, err, "Unexpected error: %v", err)
-	assert.ElementsMatch(t, expected, actual)
+
+	// Create expected paths using filepath.Join for cross-platform compatibility
+	expected := []string{
+		filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/subdir/terragrunt.hcl"),
+		filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/subdir/.terraform/modules/mod/terragrunt.hcl"),
+		filepath.Join(cwd, "../test/fixtures/config-files/ignore-terraform-data-dir/subdir/.tf_data/modules/mod/terragrunt.hcl"),
+	}
+
+	// Sort both slices to ensure consistent order for comparison
+	sort.Strings(actual)
+	sort.Strings(expected)
+
+	// Compare the paths using filepath.Clean to normalize them
+	normalizedActual := make([]string, len(actual))
+	normalizedExpected := make([]string, len(expected))
+
+	for i, path := range actual {
+		normalizedActual[i] = filepath.Clean(path)
+	}
+
+	for i, path := range expected {
+		normalizedExpected[i] = filepath.Clean(path)
+	}
+
+	assert.Equal(t, normalizedExpected, normalizedActual)
 }
 
 func TestFindConfigFilesIgnoresDownloadDir(t *testing.T) {

configstack/module_test.go

@@ -4,9 +4,12 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"runtime"
 	"strings"
 	"testing"
 
+	"github.com/gruntwork-io/terragrunt/util"
+
 	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/configstack"
 	"github.com/gruntwork-io/terragrunt/options"
@@ -50,10 +53,17 @@ digraph {
 	"h" -> "c";
 }
 `)
-	assert.Contains(t, stdout.String(), expected)
+	// clean string to work in cross-platform way
+	actual := util.CleanString(stdout.String())
+	expected = util.CleanString(expected)
+
+	assert.Contains(t, actual, expected)
 }
 
 func TestGraphTrimPrefix(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("Skipping test on Windows due to path issues")
+	}
 	t.Parallel()
 
 	a := &configstack.TerraformModule{Stack: &configstack.Stack{}, Path: "/config/a"}
@@ -89,7 +99,11 @@ digraph {
 	"alpha/beta/h" -> "c";
 }
 `)
-	assert.Contains(t, stdout.String(), expected)
+	// clean string to work in cross-platform way
+	actual := util.CleanString(stdout.String())
+	expected = util.CleanString(expected)
+
+	assert.Contains(t, actual, expected)
 }
 
 func TestGraphFlagExcluded(t *testing.T) {
@@ -128,7 +142,12 @@ digraph {
 	"h" -> "c";
 }
 `)
-	assert.Contains(t, stdout.String(), expected)
+
+	// clean string to work in cross-platform way
+	actual := util.CleanString(stdout.String())
+	expected = util.CleanString(expected)
+
+	assert.Contains(t, actual, expected)
 }
 
 func TestCheckForCycles(t *testing.T) {