fixup some complex variables

Author: Emyrk

extract/variable.go

@@ -42,37 +42,43 @@ func VariableFromBlock(block *terraform.Block) types.Variable {
 	}
 
 	var val cty.Value
+	var defSubject hcl.Range
 	if def, exists := attributes["default"]; exists {
 		val = def.NullableValue()
+		defSubject = def.HCLAttribute().Range
 	}
 
 	if valType != cty.NilType {
+		// TODO: If this code ever extracts the actual value of the variable,
+		// then we need to source the value from that, rather than the default.
 		if defaults != nil {
 			val = defaults.Apply(val)
 		}
 
+		valOK := !val.IsNull() && val.IsWhollyKnown()
 		typedVal, err := convert.Convert(val, valType)
-		if err != nil {
-			var subject hcl.Range
-			if attributes["default"].HCLAttribute() != nil {
-				subject = attributes["default"].HCLAttribute().Range
-			}
+		if err != nil && valOK {
 			return types.Variable{
 				Name: block.Label(),
 				Diagnostics: hcl.Diagnostics{&hcl.Diagnostic{
 					Severity: hcl.DiagError,
 					Summary: fmt.Sprintf("Failed to convert variable default value to type %q for %q",
 						valType.FriendlyNameForConstraint(), block.Label()),
 					Detail:  err.Error(),
-					Subject: &subject,
+					Subject: &defSubject,
 				}},
 			}
 		}
-		val = typedVal
+
+		// If the new converted value is ok, use it.
+		if err == nil {
+			val = typedVal
+		}
 	} else {
 		valType = val.Type()
 	}
 	return types.Variable{
+		Name:        block.Label(),
 		Default:     val,
 		Type:        valType,
 		Description: optionalString(block, "description"),

preview_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/zclconf/go-cty/cty"
 
 	"github.com/coder/preview"
+	"github.com/coder/preview/hclext"
 	"github.com/coder/preview/types"
 	"github.com/coder/terraform-provider-coder/v2/provider"
 )
@@ -43,6 +44,7 @@ func Test_Extract(t *testing.T) {
 		expTags     map[string]string
 		unknownTags []string
 		params      map[string]assertParam
+		variables   map[string]assertVariable
 		presets     func(t *testing.T, presets []types.Preset)
 		warnings    []*regexp.Regexp
 	}{
@@ -77,6 +79,17 @@ func Test_Extract(t *testing.T) {
 					formType(provider.ParameterFormTypeRadio),
 				"numerical": ap().value("5"),
 			},
+			variables: map[string]assertVariable{
+				"string":        av().def(cty.StringVal("Hello, world!")).typeEq(cty.String),
+				"number":        av().def(cty.NumberIntVal(7)).typeEq(cty.Number),
+				"boolean":       av().def(cty.BoolVal(true)).typeEq(cty.Bool),
+				"coerce_string": av().def(cty.StringVal("5")).typeEq(cty.String),
+				"complex": av().typeEq(cty.Object(map[string]cty.Type{
+					"list": cty.List(cty.String),
+					"name": cty.String,
+					"age":  cty.Number,
+				})),
+			},
 		},
 		{
 			name:        "conditional-no-inputs",
@@ -637,10 +650,68 @@ func Test_Extract(t *testing.T) {
 			if tc.presets != nil {
 				tc.presets(t, output.Presets)
 			}
+
+			// Assert variables
+			require.Len(t, output.Variables, len(tc.variables), "wrong number of variables expected")
+			for _, variable := range output.Variables {
+				check, ok := tc.variables[variable.Name]
+				require.True(t, ok, "unknown variable %s", variable.Name)
+				check(t, variable)
+			}
 		})
 	}
 }
 
+type assertVariable func(t *testing.T, variable types.Variable)
+
+func av() assertVariable {
+	return func(t *testing.T, v types.Variable) {
+		t.Helper()
+		assert.Empty(t, v.Diagnostics, "variable should have no diagnostics")
+	}
+}
+
+func (a assertVariable) nullable(n bool) assertVariable {
+	return a.extend(func(t *testing.T, v types.Variable) {
+		assert.Equal(t, v.Nullable, n, "variable nullable check")
+	})
+}
+
+func (a assertVariable) typeEq(ty cty.Type) assertVariable {
+	return a.extend(func(t *testing.T, v types.Variable) {
+		assert.Truef(t, ty.Equals(v.Type), "%q variable type equality check", v.Name)
+	})
+}
+
+func (a assertVariable) def(def cty.Value) assertVariable {
+	return a.extend(func(t *testing.T, v types.Variable) {
+		if !assert.Truef(t, def.Equals(v.Default).True(), "%q variable default equality check", v.Name) {
+			exp, _ := hclext.AsString(def)
+			got, _ := hclext.AsString(v.Default)
+			t.Logf("Expected: %s, Value: %s", exp, got)
+		}
+
+	})
+}
+
+func (a assertVariable) sensitive(s bool) assertVariable {
+	return a.extend(func(t *testing.T, v types.Variable) {
+		assert.Equal(t, v.Sensitive, s, "variable sensitive check")
+	})
+}
+
+func (a assertVariable) ephemeral(e bool) assertVariable {
+	return a.extend(func(t *testing.T, v types.Variable) {
+		assert.Equal(t, v.Ephemeral, e, "variable ephemeral check")
+	})
+}
+
+func (a assertVariable) description(d string) assertVariable {
+	return a.extend(func(t *testing.T, v types.Variable) {
+		assert.Equal(t, v.Description, d, "variable description check")
+	})
+}
+
 type assertParam func(t *testing.T, parameter types.Parameter)
 
 func ap() assertParam {
@@ -771,3 +842,16 @@ func (a assertParam) extend(f assertParam) assertParam {
 		f(t, parameter)
 	}
 }
+
+//nolint:revive
+func (a assertVariable) extend(f assertVariable) assertVariable {
+	if a == nil {
+		a = func(t *testing.T, v types.Variable) {}
+	}
+
+	return func(t *testing.T, v types.Variable) {
+		t.Helper()
+		(a)(t, v)
+		f(t, v)
+	}
+}

testdata/static/main.tf

@@ -12,6 +12,32 @@ terraform {
   }
 }
 
+variable "string" {
+  default = "Hello, world!"
+}
+
+variable "number" {
+  default = 7
+}
+
+variable "boolean" {
+  default = true
+}
+
+variable "coerce_string" {
+  default = 5 // This will be coerced to a string
+  type = string
+}
+
+variable "complex" {
+  type = object({
+    list   = list(string)
+    name = string
+    age  = number
+  })
+}
+
+
 data "coder_workspace_tags" "custom_workspace_tags" {
   tags = {
     "zone"        = "developers"

variables.go

@@ -11,7 +11,7 @@ import (
 )
 
 func variables(modules terraform.Modules) []types.Variable {
-	variableBlocks := modules.GetDatasByType("variable")
+	variableBlocks := modules.GetBlocks().OfType("variable")
 	vars := make([]types.Variable, 0, len(variableBlocks))
 	for _, block := range variableBlocks {
 		vars = append(vars, extract.VariableFromBlock(block))