fix: Adding integration test for stack find_in_parent_folders

Author: yhakbar

config/config_helpers.go

@@ -272,9 +272,6 @@ func getPathToRepoRoot(ctx *ParsingContext, l log.Logger) (string, error) {
 // GetTerragruntDir returns the directory where the Terragrunt configuration file lives.
 func GetTerragruntDir(ctx *ParsingContext, l log.Logger) (string, error) {
 	path := ctx.TerragruntOptions.TerragruntConfigPath
-	if val, ok := ctx.Context.Value(stackParserContext{}).(stackParserContext); ok {
-		path = val.stackConfigFile
-	}
 
 	terragruntConfigFileAbsPath, err := filepath.Abs(path)
 	if err != nil {

config/config_helpers_test.go

@@ -1,6 +1,7 @@
 package config_test
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -333,6 +334,49 @@ func TestFindInParentFolders(t *testing.T) {
 	}
 }
 
+func TestFindInParentFoldersWithStackFile(t *testing.T) {
+	t.Parallel()
+
+	tempDir := t.TempDir()
+
+	regionHclPath := filepath.Join(tempDir, "region.hcl")
+	regionHclContent := `locals {
+  aws_region = "us-east-1"
+}`
+	err := os.WriteFile(regionHclPath, []byte(regionHclContent), 0644)
+	require.NoError(t, err)
+
+	stackDir := filepath.Join(tempDir, "stack")
+	err = os.MkdirAll(stackDir, 0755)
+	require.NoError(t, err)
+
+	stackHclPath := filepath.Join(stackDir, "terragrunt.stack.hcl")
+	stackHclContent := `locals {
+  regions_vars = read_terragrunt_config(find_in_parent_folders("region.hcl"))
+  region       = local.regions_vars.locals.aws_region
+}
+
+unit "test" {
+  source = "."
+  path   = "test"
+}`
+	err = os.WriteFile(stackHclPath, []byte(stackHclContent), 0644)
+	require.NoError(t, err)
+
+	l := logger.CreateLogger()
+	opts, err := options.NewTerragruntOptionsForTest(stackHclPath)
+	require.NoError(t, err)
+	opts.WorkingDir = tempDir
+
+	stackConfig, err := config.ReadStackConfigFile(context.Background(), l, opts, stackHclPath, nil)
+	require.NoError(t, err)
+	require.NotNil(t, stackConfig)
+
+	region, exists := stackConfig.Locals["region"]
+	require.True(t, exists, "Expected 'region' local to be parsed")
+	require.Equal(t, "us-east-1", region)
+}
+
 func TestResolveTerragruntInterpolation(t *testing.T) {
 	t.Parallel()
 

config/stack.go

@@ -74,10 +74,6 @@ type Stack struct {
 	Path         string     `hcl:"path,attr"`
 }
 
-type stackParserContext struct {
-	stackConfigFile string
-}
-
 // GenerateStacks generates the stack files.
 func GenerateStacks(ctx context.Context, l log.Logger, opts *options.TerragruntOptions) error {
 	processedFiles := make(map[string]bool)
@@ -693,8 +689,10 @@ func (u *Unit) ReadOutputs(ctx context.Context, l log.Logger, opts *options.Terr
 func ReadStackConfigFile(ctx context.Context, l log.Logger, opts *options.TerragruntOptions, filePath string, values *cty.Value) (*StackConfig, error) {
 	l.Debugf("Reading Terragrunt stack config file at %s", filePath)
 
-	ctx = context.WithValue(ctx, stackParserContext{}, stackParserContext{stackConfigFile: filePath})
-	parser := NewParsingContext(ctx, l, opts)
+	stackOpts := opts.Clone()
+	stackOpts.TerragruntConfigPath = filePath
+
+	parser := NewParsingContext(ctx, l, stackOpts)
 
 	file, err := hclparse.NewParser(parser.ParserOptions...).ParseFromFile(filePath)
 	if err != nil {

test/fixtures/stacks/find-in-parent-folders/live/stack/terragrunt.stack.hcl

@@ -0,0 +1,13 @@
+locals {
+  mock_vars = read_terragrunt_config(find_in_parent_folders("mock.hcl"))
+  mock       = local.mock_vars.locals.mock
+}
+
+unit "foo" {
+  source = "../../units/foo"
+  path   = "foo"
+
+  values = {
+    mock = local.mock
+  }
+}

test/fixtures/stacks/find-in-parent-folders/mock.hcl

@@ -0,0 +1,3 @@
+locals {
+  mock = "mock"
+}

test/fixtures/stacks/find-in-parent-folders/units/foo/main.tf

@@ -0,0 +1,8 @@
+variable "mock" {
+  description = "Mock value to be passed through"
+  type        = string
+}
+
+output "mock" {
+  value = var.mock
+}

test/fixtures/stacks/find-in-parent-folders/units/foo/terragrunt.hcl

@@ -0,0 +1,7 @@
+terraform {
+  source = "."
+}
+
+inputs = {
+  mock = values.mock
+}

test/integration_stacks_test.go

@@ -50,6 +50,7 @@ const (
 	testFixtureStackTerragruntDir              = "fixtures/stacks/terragrunt-dir"
 	testFixtureStacksAllNoStackDir             = "fixtures/stacks/all-no-stack-dir"
 	testFixtureStackNoDotTerragruntStackOutput = "fixtures/stacks/no-dot-terragrunt-stack-output"
+	testFixtureStackFindInParentFolders        = "fixtures/stacks/find-in-parent-folders"
 )
 
 func TestStacksGenerateBasicWithQueueIncludeDirFlag(t *testing.T) {
@@ -1393,3 +1394,47 @@ func TestStackOutputWithNoDotTerragruntStack(t *testing.T) {
 
 	assert.Contains(t, stdout, "name = \"app1\"")
 }
+
+func TestStackFindInParentFolders(t *testing.T) {
+	t.Parallel()
+
+	helpers.CleanupTerraformFolder(t, testFixtureStackFindInParentFolders)
+	tmpEnvPath := helpers.CopyEnvironment(t, testFixtureStackFindInParentFolders)
+	rootPath := util.JoinPath(tmpEnvPath, testFixtureStackFindInParentFolders, "live")
+
+	// Test that stack generation works from the live directory
+	helpers.RunTerragrunt(t, "terragrunt stack generate --working-dir "+rootPath)
+
+	// Verify that the stack directory was created and contains the expected unit
+	stackDir := util.JoinPath(rootPath, "stack", ".terragrunt-stack")
+	validateStackDir(t, stackDir)
+
+	// Verify that the foo unit was generated
+	fooUnitPath := util.JoinPath(stackDir, "foo")
+	assert.True(t, util.FileExists(fooUnitPath), "Expected foo unit to exist in .terragrunt-stack directory")
+	assert.True(t, util.FileExists(util.JoinPath(fooUnitPath, "terragrunt.hcl")), "Expected terragrunt.hcl to exist in foo unit")
+
+	// Test that stack generation works from the parent directory (this tests our fix)
+	parentPath := util.JoinPath(tmpEnvPath, testFixtureStackFindInParentFolders)
+	helpers.RunTerragrunt(t, "terragrunt stack generate --working-dir "+parentPath)
+
+	// Verify that the stack directory was created from the parent directory
+	parentStackDir := util.JoinPath(parentPath, "live", "stack", ".terragrunt-stack")
+	validateStackDir(t, parentStackDir)
+
+	// Verify that the foo unit was generated from the parent directory
+	parentFooUnitPath := util.JoinPath(parentStackDir, "foo")
+	assert.True(t, util.FileExists(parentFooUnitPath), "Expected foo unit to exist when generating from parent directory")
+	assert.True(t, util.FileExists(util.JoinPath(parentFooUnitPath, "terragrunt.hcl")), "Expected terragrunt.hcl to exist in foo unit when generating from parent directory")
+
+	stackPath := util.JoinPath(rootPath, "stack")
+
+	_, _, err := helpers.RunTerragruntCommandWithOutput(t, "terragrunt stack run apply --non-interactive --working-dir "+stackPath)
+	require.NoError(t, err, "Expected stack run apply to succeed")
+
+	outputStdout, _, err := helpers.RunTerragruntCommandWithOutput(t, "terragrunt stack output --raw foo.mock --non-interactive --working-dir "+stackPath)
+	require.NoError(t, err, "Expected stack output to succeed")
+
+	// Verify that the mock value from mock.hcl was correctly passed through
+	assert.Equal(t, "mock", strings.TrimSpace(outputStdout), "Expected raw output to contain just the mock value")
+}