refactor variable extraction

Author: DanielMSchmidt

internal/backend/local/test.go

@@ -997,34 +997,30 @@ func (runner *TestFileRunner) GetVariables(config *configs.Config, run *modulete
 		}
 	}
 
-	// Second, we'll check to see which variables the suites global variables
-	// themselves reference.
-	for _, expr := range runner.fileVariables {
-		for _, variable := range expr.Variables() {
-			reference, referenceDiags := addrs.ParseRefFromTestingScope(variable)
-			diags = diags.Append(referenceDiags)
-			if reference != nil {
-				if addr, ok := reference.Subject.(addrs.InputVariable); ok {
-					relevantVariables[addr.Name] = true
+	getRelevantVariables := func(src map[string]hcl.Expression) tfdiags.Diagnostics {
+		var getVarsDiags tfdiags.Diagnostics
+		for _, expr := range runner.fileVariables {
+			for _, variable := range expr.Variables() {
+				reference, referenceDiags := addrs.ParseRefFromTestingScope(variable)
+				getVarsDiags = getVarsDiags.Append(referenceDiags)
+				if reference != nil {
+					if addr, ok := reference.Subject.(addrs.InputVariable); ok {
+						relevantVariables[addr.Name] = true
+					}
 				}
 			}
 		}
+		return getVarsDiags
 	}
 
+	// Second, we'll check to see which variables the suites global variables
+	// themselves reference.
+	diags = diags.Append(getRelevantVariables(runner.fileVariables))
+
 	// Third, we'll check to see which variables the run block variables
 	// themselves reference. We might be processing variables just for the file
 	// so the run block itself could be nil.
-	for _, expr := range run.Config.Variables {
-		for _, variable := range expr.Variables() {
-			reference, referenceDiags := addrs.ParseRefFromTestingScope(variable)
-			diags = diags.Append(referenceDiags)
-			if reference != nil {
-				if addr, ok := reference.Subject.(addrs.InputVariable); ok {
-					relevantVariables[addr.Name] = true
-				}
-			}
-		}
-	}
+	diags = diags.Append(getRelevantVariables(run.Config.Variables))
 
 	// Finally, we'll check to see which variables are actually defined within
 	// the configuration.
@@ -1080,96 +1076,101 @@ func (runner *TestFileRunner) GetVariables(config *configs.Config, run *modulete
 	}
 
 	// Second, we'll check the file level variables
-	var exprs []hcl.Expression
-	for _, expr := range runner.fileVariables {
-		exprs = append(exprs, expr)
+	// This is a bit more complicated, as the file and run level variables can reference
+	// previously defined variables.
+	fileValues, fileDiags := runner.getVariablesFromConfiguration(values, relevantVariables, run.Name, runner.fileVariables)
+	diags = diags.Append(fileDiags)
+	for name, value := range fileValues {
+		values[name] = value
 	}
 
-	// Preformat the variables we've processed already - these will be made
-	// available to the eval context.
-	variables := make(map[string]cty.Value)
-	for name, value := range values {
-		variables[name] = value.Value
+	// Third, we'll check the run level variables.
+	runValues, runDiags := runner.getVariablesFromConfiguration(values, relevantVariables, run.Name, run.Config.Variables)
+	diags = diags.Append(runDiags)
+	for name, value := range runValues {
+		values[name] = value
 	}
 
-	fmt.Printf("\nvariables: \n\t%#v \n", variables)
+	// Finally, we check the configuration again. This is where we'll discover
+	// if there's any missing variables and fill in any optional variables that
+	// don't have a value already.
 
-	ctx, ctxDiags := hcltest.EvalContext(hcltest.TargetRunBlock, exprs, variables, runner.PriorOutputs)
-	diags = diags.Append(ctxDiags)
+	for name, variable := range config.Module.Variables {
+		if _, exists := values[name]; exists {
+			// Then we've provided a variable for this. It's all good.
+			continue
+		}
 
-	var failedContext bool
-	if ctxDiags.HasErrors() {
-		// If we couldn't build the context, we won't actually process these
-		// variables. Instead, we'll fill them with an empty value but still
-		// make a note that the user did provide them.
-		failedContext = true
-	}
+		// Otherwise, we're going to give these variables a value. They'll be
+		// processed by the Terraform graph and provided a default value later
+		// if they have one.
 
-	for name, expr := range runner.fileVariables {
-		if !relevantVariables[name] {
-			// We'll add a warning for this. Since we're right in the run block
-			// users shouldn't be defining variables that are not relevant.
+		if variable.Required() {
 			diags = diags.Append(&hcl.Diagnostic{
-				Severity: hcl.DiagWarning,
-				Summary:  "Value for undeclared variable",
-				Detail:   fmt.Sprintf("The module under test does not declare a variable named %q, but it is declared in run block %q.", name, run.Name),
-				Subject:  expr.Range().Ptr(),
+				Severity: hcl.DiagError,
+				Summary:  "No value for required variable",
+				Detail: fmt.Sprintf("The module under test for run block %q has a required variable %q with no set value. Use a -var or -var-file command line argument or add this variable into a \"variables\" block within the test file or run block.",
+					run.Name, variable.Name),
+				Subject: variable.DeclRange.Ptr(),
 			})
-			continue
-		}
 
-		value := cty.NilVal
-		if !failedContext {
-			var valueDiags hcl.Diagnostics
-			value, valueDiags = expr.Value(ctx)
-			diags = diags.Append(valueDiags)
+			values[name] = &terraform.InputValue{
+				Value:       cty.DynamicVal,
+				SourceType:  terraform.ValueFromConfig,
+				SourceRange: tfdiags.SourceRangeFromHCL(variable.DeclRange),
+			}
+		} else {
+			values[name] = &terraform.InputValue{
+				Value:       cty.NilVal,
+				SourceType:  terraform.ValueFromConfig,
+				SourceRange: tfdiags.SourceRangeFromHCL(variable.DeclRange),
+			}
 		}
 
-		values[name] = &terraform.InputValue{
-			Value:       value,
-			SourceType:  terraform.ValueFromConfig,
-			SourceRange: tfdiags.SourceRangeFromHCL(expr.Range()),
-		}
 	}
 
-	// Third, we'll check the run level variables.
+	return values, diags
+}
 
-	// This is a bit more complicated, as the run level variables can reference
-	// previously defined variables.
+// getVariablesFromConfiguration will process the variables from the configuration
+// and return a map of the variables and their values.
+func (runner *TestFileRunner) getVariablesFromConfiguration(knownVariables terraform.InputValues, relevantVariables map[string]bool, runName string, variableConfig map[string]hcl.Expression) (terraform.InputValues, tfdiags.Diagnostics) {
+	var exprs []hcl.Expression
+	var diags tfdiags.Diagnostics
+	variableValues := make(terraform.InputValues)
 
 	// Preload the available expressions, we're going to validate them when we
 	// build the context.
-	exprs = []hcl.Expression{}
-	for _, expr := range run.Config.Variables {
+	for _, expr := range runner.fileVariables {
 		exprs = append(exprs, expr)
 	}
 
 	// Preformat the variables we've processed already - these will be made
 	// available to the eval context.
-	variables = make(map[string]cty.Value)
-	for name, value := range values {
+	variables := make(map[string]cty.Value)
+	for name, value := range knownVariables {
 		variables[name] = value.Value
 	}
 
-	ctx, ctxDiags = hcltest.EvalContext(hcltest.TargetRunBlock, exprs, variables, runner.PriorOutputs)
+	ctx, ctxDiags := hcltest.EvalContext(hcltest.TargetRunBlock, exprs, variables, runner.PriorOutputs)
 	diags = diags.Append(ctxDiags)
 
-	failedContext = false
+	var failedContext bool
 	if ctxDiags.HasErrors() {
 		// If we couldn't build the context, we won't actually process these
 		// variables. Instead, we'll fill them with an empty value but still
 		// make a note that the user did provide them.
 		failedContext = true
 	}
 
-	for name, expr := range run.Config.Variables {
+	for name, expr := range runner.fileVariables {
 		if !relevantVariables[name] {
 			// We'll add a warning for this. Since we're right in the run block
 			// users shouldn't be defining variables that are not relevant.
 			diags = diags.Append(&hcl.Diagnostic{
 				Severity: hcl.DiagWarning,
 				Summary:  "Value for undeclared variable",
-				Detail:   fmt.Sprintf("The module under test does not declare a variable named %q, but it is declared in run block %q.", name, run.Name),
+				Detail:   fmt.Sprintf("The module under test does not declare a variable named %q, but it is declared in run block %q.", name, runName),
 				Subject:  expr.Range().Ptr(),
 			})
 			continue
@@ -1182,52 +1183,14 @@ func (runner *TestFileRunner) GetVariables(config *configs.Config, run *modulete
 			diags = diags.Append(valueDiags)
 		}
 
-		values[name] = &terraform.InputValue{
+		variableValues[name] = &terraform.InputValue{
 			Value:       value,
 			SourceType:  terraform.ValueFromConfig,
 			SourceRange: tfdiags.SourceRangeFromHCL(expr.Range()),
 		}
 	}
 
-	// Finally, we check the configuration again. This is where we'll discover
-	// if there's any missing variables and fill in any optional variables that
-	// don't have a value already.
-
-	for name, variable := range config.Module.Variables {
-		if _, exists := values[name]; exists {
-			// Then we've provided a variable for this. It's all good.
-			continue
-		}
-
-		// Otherwise, we're going to give these variables a value. They'll be
-		// processed by the Terraform graph and provided a default value later
-		// if they have one.
-
-		if variable.Required() {
-			diags = diags.Append(&hcl.Diagnostic{
-				Severity: hcl.DiagError,
-				Summary:  "No value for required variable",
-				Detail: fmt.Sprintf("The module under test for run block %q has a required variable %q with no set value. Use a -var or -var-file command line argument or add this variable into a \"variables\" block within the test file or run block.",
-					run.Name, variable.Name),
-				Subject: variable.DeclRange.Ptr(),
-			})
-
-			values[name] = &terraform.InputValue{
-				Value:       cty.DynamicVal,
-				SourceType:  terraform.ValueFromConfig,
-				SourceRange: tfdiags.SourceRangeFromHCL(variable.DeclRange),
-			}
-		} else {
-			values[name] = &terraform.InputValue{
-				Value:       cty.NilVal,
-				SourceType:  terraform.ValueFromConfig,
-				SourceRange: tfdiags.SourceRangeFromHCL(variable.DeclRange),
-			}
-		}
-
-	}
-
-	return values, diags
+	return variableValues, diags
 }
 
 // FilterVariablesToModule splits the provided values into two disjoint maps:
@@ -1324,17 +1287,20 @@ func (runner *TestFileRunner) AddVariablesToConfig(config *configs.Config, varia
 // the file.
 func (runner *TestFileRunner) initVariables(file *moduletest.File) {
 	runner.globalVariables = make(map[string]backend.UnparsedVariableValue)
+	fmt.Printf("\nrunner.Suite.GlobalVariables: \n\t%#v \n", runner.Suite.GlobalVariables)
 	for name, value := range runner.Suite.GlobalVariables {
 		runner.globalVariables[name] = value
 	}
 	if filepath.Dir(file.Name) == runner.Suite.TestingDirectory {
 		// If the file is in the testing directory, then also include any
 		// variables that are defined within the default variable file also in
 		// the test directory.
+		fmt.Printf("\nrunner.Suite.GlobalTestVariables: \n\t%#v \n", runner.Suite.GlobalTestVariables)
 		for name, value := range runner.Suite.GlobalTestVariables {
 			runner.globalVariables[name] = value
 		}
 	}
+	fmt.Printf("\nfile.Config.Variables: \n\t%#v \n", file.Config.Variables)
 	runner.fileVariables = make(map[string]hcl.Expression)
 	for name, expr := range file.Config.Variables {
 		runner.fileVariables[name] = expr