chore: Verify --queue-include-external isn't necessary when using the --filter flag

Author: yhakbar

test/integration_dag_test.go

@@ -33,7 +33,22 @@ func TestIncludeExternalInDagGraphCmd(t *testing.T) {
 	workDir, err := filepath.EvalSymlinks(workDir)
 	require.NoError(t, err)
 
-	cmd := "terragrunt dag graph --queue-include-external --working-dir " + workDir
+	cmd := "terragrunt dag graph --working-dir " + workDir
+
+	stdout, _, err := helpers.RunTerragruntCommandWithOutput(t, cmd)
+	require.NoError(t, err)
+	assert.Contains(t, stdout, "unit-a\" ->")
+}
+
+func TestIncludeExternalInDagGraphCmdWithList(t *testing.T) {
+	t.Parallel()
+
+	helpers.CleanupTerraformFolder(t, testFixtureGraphDAG)
+	workDir := filepath.Join(testFixtureGraphDAG, "region-1")
+	workDir, err := filepath.EvalSymlinks(workDir)
+	require.NoError(t, err)
+
+	cmd := "terragrunt list --format=dot --dependencies --working-dir " + workDir
 
 	stdout, _, err := helpers.RunTerragruntCommandWithOutput(t, cmd)
 	require.NoError(t, err)

test/integration_download_test.go

@@ -741,6 +741,47 @@ func TestTerragruntExternalDependencies(t *testing.T) {
 	}
 }
 
+func TestTerragruntExternalDependenciesWithFilter(t *testing.T) {
+	t.Parallel()
+
+	if !helpers.IsExperimentMode(t) {
+		t.Skip("Skipping filter flag tests - TG_EXPERIMENT_MODE not enabled")
+	}
+
+	modules := []string{
+		"module-a",
+		"module-b",
+	}
+
+	helpers.CleanupTerraformFolder(t, testFixtureExternalDependence)
+
+	for _, module := range modules {
+		helpers.CleanupTerraformFolder(t, util.JoinPath(testFixtureExternalDependence, module))
+	}
+
+	var (
+		applyAllStdout bytes.Buffer
+		applyAllStderr bytes.Buffer
+	)
+
+	rootPath := helpers.CopyEnvironment(t, testFixtureExternalDependence)
+	modulePath := util.JoinPath(rootPath, testFixtureExternalDependence, "module-b")
+
+	err := helpers.RunTerragruntCommand(t, "terragrunt run --all apply --non-interactive --filter '{./**}...' --tf-forward-stdout --working-dir "+modulePath, &applyAllStdout, &applyAllStderr)
+	helpers.LogBufferContentsLineByLine(t, applyAllStdout, "run --all apply stdout")
+	helpers.LogBufferContentsLineByLine(t, applyAllStderr, "run --all apply stderr")
+
+	applyAllStdoutString := applyAllStdout.String()
+
+	if err != nil {
+		t.Errorf("Did not expect to get error: %s", err.Error())
+	}
+
+	for _, module := range modules {
+		assert.Contains(t, applyAllStdoutString, "Hello World, "+module)
+	}
+}
+
 func TestPreventDestroy(t *testing.T) {
 	t.Parallel()
 

test/integration_include_test.go

@@ -65,6 +65,47 @@ func TestTerragruntWorksWithIncludeLocals(t *testing.T) {
 		})
 	}
 }
+func TestTerragruntWorksWithIncludeLocalsWithFilter(t *testing.T) {
+	t.Parallel()
+
+	if !helpers.IsExperimentMode(t) {
+		t.Skip("Skipping filter flag tests - TG_EXPERIMENT_MODE not enabled")
+	}
+
+	helpers.CleanupTerraformFolder(t, includeExposeFixturePath)
+	tmpEnvPath := helpers.CopyEnvironment(t, includeExposeFixturePath)
+	tmpEnvPath = util.JoinPath(tmpEnvPath, includeExposeFixturePath)
+
+	files, err := os.ReadDir(tmpEnvPath)
+	require.NoError(t, err)
+
+	testCases := []string{}
+
+	for _, finfo := range files {
+		if finfo.IsDir() {
+			testCases = append(testCases, finfo.Name())
+		}
+	}
+
+	for _, tc := range testCases {
+		t.Run(filepath.Base(tc), func(t *testing.T) {
+			t.Parallel()
+
+			childPath := filepath.Join(tmpEnvPath, tc, includeChildFixturePath)
+			helpers.CleanupTerraformFolder(t, childPath)
+			helpers.RunTerragrunt(t, "terragrunt run --all --filter '{./**}...' --non-interactive --log-level trace --working-dir "+childPath+" -- apply -auto-approve")
+
+			stdout := bytes.Buffer{}
+			stderr := bytes.Buffer{}
+			err := helpers.RunTerragruntCommand(t, "terragrunt output -no-color -json --non-interactive --log-level trace --working-dir "+childPath, &stdout, &stderr)
+			require.NoError(t, err)
+
+			outputs := map[string]helpers.TerraformOutput{}
+			require.NoError(t, json.Unmarshal(stdout.Bytes(), &outputs))
+			assert.Equal(t, "us-west-1-test", outputs["region"].Value.(string))
+		})
+	}
+}
 
 func TestTerragruntRunAllModulesThatIncludeRestrictsSet(t *testing.T) {
 	t.Parallel()

test/integration_runner_pool_test.go

@@ -102,7 +102,10 @@ func TestRunnerPoolStackConfigIgnored(t *testing.T) {
 	helpers.CleanupTerraformFolder(t, tmpEnvPath)
 	testPath := util.JoinPath(tmpEnvPath, testFixtureMixedConfig)
 
-	_, stderr, err := helpers.RunTerragruntCommandWithOutput(t, "terragrunt run --queue-include-external --all --non-interactive --working-dir "+testPath+" -- apply")
+	_, stderr, err := helpers.RunTerragruntCommandWithOutput(
+		t,
+		"terragrunt run --all --non-interactive --working-dir "+testPath+" -- apply",
+	)
 	require.NoError(t, err)
 	require.NotContains(t, stderr, "Error: Unsupported block type")
 	require.NotContains(t, stderr, "Blocks of type \"unit\" are not expected here")