load tf vars for e2e

Author: Emyrk

internal/verify/exec.go

@@ -56,14 +56,15 @@ func (e WorkingExecutable) Init(ctx context.Context) error {
 	return e.TF.Init(ctx, tfexec.Upgrade(true))
 }
 
-func (e WorkingExecutable) Plan(ctx context.Context, outPath string) (bool, error) {
-	changes, err := e.TF.Plan(ctx, tfexec.Out(outPath))
+func (e WorkingExecutable) Plan(ctx context.Context, outPath string, opts ...tfexec.PlanOption) (bool, error) {
+	opts = append(opts, tfexec.Out(outPath))
+	changes, err := e.TF.Plan(ctx, opts...)
 	return changes, err
 }
 
-func (e WorkingExecutable) Apply(ctx context.Context) ([]byte, error) {
+func (e WorkingExecutable) Apply(ctx context.Context, opts ...tfexec.ApplyOption) ([]byte, error) {
 	var out bytes.Buffer
-	err := e.TF.ApplyJSON(ctx, &out)
+	err := e.TF.ApplyJSON(ctx, &out, opts...)
 	return out.Bytes(), err
 }
 

preview.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"io/fs"
 	"log/slog"
-	"path/filepath"
-	"strings"
 
 	"github.com/aquasecurity/trivy/pkg/iac/scanners/terraform/parser"
 	"github.com/hashicorp/hcl/v2"
@@ -85,7 +83,7 @@ func Preview(ctx context.Context, input Input, dir fs.FS) (output *Output, diagn
 		}
 	}()
 
-	varFiles, err := tfVarFiles("", dir)
+	varFiles, err := tfvars.TFVarFiles("", dir)
 	if err != nil {
 		return nil, hcl.Diagnostics{
 			{
@@ -197,33 +195,3 @@ func (i Input) RichParameterValue(key string) (string, bool) {
 	p, ok := i.ParameterValues[key]
 	return p, ok
 }
-
-// tfVarFiles extracts any .tfvars files from the given directory.
-// TODO: Test nested directories and how that should behave.
-func tfVarFiles(path string, dir fs.FS) ([]string, error) {
-	dp := "."
-	entries, err := fs.ReadDir(dir, dp)
-	if err != nil {
-		return nil, fmt.Errorf("read dir %q: %w", dp, err)
-	}
-
-	files := make([]string, 0)
-	for _, entry := range entries {
-		if entry.IsDir() {
-			subD, err := fs.Sub(dir, entry.Name())
-			if err != nil {
-				return nil, fmt.Errorf("sub dir %q: %w", entry.Name(), err)
-			}
-			newFiles, err := tfVarFiles(filepath.Join(path, entry.Name()), subD)
-			if err != nil {
-				return nil, err
-			}
-			files = append(files, newFiles...)
-		}
-
-		if filepath.Ext(entry.Name()) == ".tfvars" || strings.HasSuffix(entry.Name(), ".tfvars.json") {
-			files = append(files, filepath.Join(path, entry.Name()))
-		}
-	}
-	return files, nil
-}

previewe2e_test.go

@@ -10,10 +10,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/hashicorp/terraform-exec/tfexec"
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/preview"
 	"github.com/coder/preview/internal/verify"
+	"github.com/coder/preview/tfvars"
 	"github.com/coder/preview/types"
 )
 
@@ -102,11 +104,11 @@ func Test_VerifyE2E(t *testing.T) {
 
 			entryWrkPath := t.TempDir()
 
-			for _, tfexec := range tfexecs {
-				tfexec := tfexec
+			for _, tfexecutable := range tfexecs {
+				tfexecutable := tfexecutable
 
-				t.Run(tfexec.Version, func(t *testing.T) {
-					wp := filepath.Join(entryWrkPath, tfexec.Version)
+				t.Run(tfexecutable.Version, func(t *testing.T) {
+					wp := filepath.Join(entryWrkPath, tfexecutable.Version)
 					err := os.MkdirAll(wp, 0755)
 					require.NoError(t, err, "creating working dir")
 
@@ -118,17 +120,27 @@ func Test_VerifyE2E(t *testing.T) {
 					err = verify.CopyTFFS(wp, subFS)
 					require.NoError(t, err, "copying test data to working dir")
 
-					exe, err := tfexec.WorkingDir(wp)
+					exe, err := tfexecutable.WorkingDir(wp)
 					require.NoError(t, err, "creating working executable")
 
 					ctx, cancel := context.WithTimeout(context.Background(), time.Minute*2)
 					defer cancel()
 					err = exe.Init(ctx)
 					require.NoError(t, err, "terraform init")
 
+					tfVarFiles, err := tfvars.TFVarFiles("", subFS)
+					require.NoError(t, err, "loading tfvars files")
+
+					planOpts := make([]tfexec.PlanOption, 0)
+					applyOpts := make([]tfexec.ApplyOption, 0)
+					for _, varFile := range tfVarFiles {
+						planOpts = append(planOpts, tfexec.VarFile(varFile))
+						applyOpts = append(applyOpts, tfexec.VarFile(varFile))
+					}
+
 					planOutFile := "tfplan"
 					planOutPath := filepath.Join(wp, planOutFile)
-					_, err = exe.Plan(ctx, planOutPath)
+					_, err = exe.Plan(ctx, planOutPath, planOpts...)
 					require.NoError(t, err, "terraform plan")
 
 					plan, err := exe.ShowPlan(ctx, planOutPath)
@@ -141,7 +153,7 @@ func Test_VerifyE2E(t *testing.T) {
 					err = os.WriteFile(filepath.Join(wp, "plan.json"), pd, 0644)
 					require.NoError(t, err, "writing plan.json")
 
-					_, err = exe.Apply(ctx)
+					_, err = exe.Apply(ctx, applyOpts...)
 					require.NoError(t, err, "terraform apply")
 
 					state, err := exe.Show(ctx)

tfvars/load.go

@@ -13,6 +13,36 @@ import (
 	"github.com/zclconf/go-cty/cty"
 )
 
+// TFVarFiles extracts any .tfvars files from the given directory.
+// TODO: Test nested directories and how that should behave.
+func TFVarFiles(path string, dir fs.FS) ([]string, error) {
+	dp := "."
+	entries, err := fs.ReadDir(dir, dp)
+	if err != nil {
+		return nil, fmt.Errorf("read dir %q: %w", dp, err)
+	}
+
+	files := make([]string, 0)
+	for _, entry := range entries {
+		if entry.IsDir() {
+			subD, err := fs.Sub(dir, entry.Name())
+			if err != nil {
+				return nil, fmt.Errorf("sub dir %q: %w", entry.Name(), err)
+			}
+			newFiles, err := TFVarFiles(filepath.Join(path, entry.Name()), subD)
+			if err != nil {
+				return nil, err
+			}
+			files = append(files, newFiles...)
+		}
+
+		if filepath.Ext(entry.Name()) == ".tfvars" || strings.HasSuffix(entry.Name(), ".tfvars.json") {
+			files = append(files, filepath.Join(path, entry.Name()))
+		}
+	}
+	return files, nil
+}
+
 func LoadTFVars(srcFS fs.FS, filenames []string) (map[string]cty.Value, error) {
 	combinedVars := make(map[string]cty.Value)