begin adding invalid unit tests

Emyrk · Emyrk · commit c640b02427d3 · 2025-04-14T16:35:09.000-05:00
diff --git a/provider/parameter.go b/provider/parameter.go
@@ -50,7 +50,6 @@ const (
 )
 
 type Parameter struct {
-	Value       string
 	Name        string
 	DisplayName string `mapstructure:"display_name"`
 	Description string
@@ -86,7 +85,6 @@ func parameterDataSource() *schema.Resource {
 
 			var parameter Parameter
 			err = mapstructure.Decode(struct {
-				Value       interface{}
 				Name        interface{}
 				DisplayName interface{}
 				Description interface{}
@@ -101,7 +99,6 @@ func parameterDataSource() *schema.Resource {
 				Order       interface{}
 				Ephemeral   interface{}
 			}{
-				Value:       rd.Get("value"),
 				Name:        rd.Get("name"),
 				DisplayName: rd.Get("display_name"),
 				Description: rd.Get("description"),
@@ -126,14 +123,7 @@ func parameterDataSource() *schema.Resource {
 			if err != nil {
 				return diag.Errorf("decode parameter: %s", err)
 			}
-			var value string
-			if parameter.Default != "" {
-				err := valueIsType(parameter.Type, parameter.Default, defaultValuePath)
-				if err != nil {
-					return err
-				}
-				value = parameter.Default
-			}
+			value := parameter.Default
 			envValue, ok := os.LookupEnv(ParameterEnvironmentVariable(parameter.Name))
 			if ok {
 				value = envValue
@@ -381,27 +371,27 @@ func fixValidationResourceData(rawConfig cty.Value, validation interface{}) (int
 	return vArr, nil
 }
 
-func valueIsType(typ OptionType, value string, attrPath cty.Path) diag.Diagnostics {
+func valueIsType(typ OptionType, value string) error {
 	switch typ {
 	case OptionTypeNumber:
 		_, err := strconv.ParseFloat(value, 64)
 		if err != nil {
-			return diag.Errorf("%q is not a number", value)
+			return fmt.Errorf("%q is not a number", value)
 		}
 	case OptionTypeBoolean:
 		_, err := strconv.ParseBool(value)
 		if err != nil {
-			return diag.Errorf("%q is not a bool", value)
+			return fmt.Errorf("%q is not a bool", value)
 		}
 	case OptionTypeListString:
-		_, diags := valueIsListString(value, attrPath)
-		if diags.HasError() {
-			return diags
+		_, err := valueIsListString(value)
+		if err != nil {
+			return err
 		}
 	case OptionTypeString:
 		// Anything is a string!
 	default:
-		return diag.Errorf("invalid type %q", typ)
+		return fmt.Errorf("invalid type %q", typ)
 	}
 	return nil
 }
@@ -447,9 +437,15 @@ func (v *Parameter) Valid(value string) diag.Diagnostics {
 					},
 				}
 			}
-			diags := valueIsType(optionType, option.Value, cty.Path{})
-			if diags.HasError() {
-				return diags
+			err = valueIsType(optionType, option.Value)
+			if err != nil {
+				return diag.Diagnostics{
+					{
+						Severity: diag.Error,
+						Summary:  fmt.Sprintf("Option %q with value=%q is not of type %q", option.Name, option.Value, optionType),
+						Detail:   err.Error(),
+					},
+				}
 			}
 			optionValues[option.Value] = nil
 			optionNames[option.Name] = nil
@@ -461,6 +457,18 @@ func (v *Parameter) Valid(value string) diag.Diagnostics {
 
 	// Validate the default value
 	if v.Default != "" {
+		err := valueIsType(v.Type, v.Default)
+		if err != nil {
+			return diag.Diagnostics{
+				{
+					Severity:      diag.Error,
+					Summary:       fmt.Sprintf("Default value is not of type %q", v.Type),
+					Detail:        err.Error(),
+					AttributePath: defaultValuePath,
+				},
+			}
+		}
+
 		d := v.validValue(v.Default, optionType, optionValues, defaultValuePath)
 		if d.HasError() {
 			return d
@@ -473,6 +481,17 @@ func (v *Parameter) Valid(value string) diag.Diagnostics {
 		return d
 	}
 
+	err = valueIsType(v.Type, value)
+	if err != nil {
+		return diag.Diagnostics{
+			{
+				Severity: diag.Error,
+				Summary:  fmt.Sprintf("Parameter value is not of type %q", v.Type),
+				Detail:   err.Error(),
+			},
+		}
+	}
+
 	return nil
 }
 
@@ -488,9 +507,16 @@ func (v *Parameter) validValue(value string, optionType OptionType, optionValues
 		if v.Type == OptionTypeListString && optionType == OptionTypeString {
 			// If the type is list(string) and optionType is string, we have
 			// to ensure all elements of the default exist as options.
-			listValues, diags := valueIsListString(value, defaultValuePath)
-			if diags.HasError() {
-				return diags
+			listValues, err := valueIsListString(value)
+			if err != nil {
+				return diag.Diagnostics{
+					{
+						Severity:      diag.Error,
+						Summary:       "When using list(string) type, value must be a json encoded list of strings",
+						Detail:        err.Error(),
+						AttributePath: defaultValuePath,
+					},
+				}
 			}
 
 			// missing is used to construct a more helpful error message
@@ -608,18 +634,11 @@ func (v *Validation) Valid(typ OptionType, value string) error {
 	return nil
 }
 
-func valueIsListString(value string, path cty.Path) ([]string, diag.Diagnostics) {
+func valueIsListString(value string) ([]string, error) {
 	var items []string
 	err := json.Unmarshal([]byte(value), &items)
 	if err != nil {
-		return nil, diag.Diagnostics{
-			{
-				Severity:      diag.Error,
-				Summary:       "When using list(string) type, value must be a json encoded list of strings",
-				Detail:        fmt.Sprintf("value %q is not a valid list of strings", value),
-				AttributePath: path,
-			},
-		}
+		return nil, fmt.Errorf("value %q is not a valid list of strings", value)
 	}
 	return items, nil
 }
diff --git a/provider/parameter_test.go b/provider/parameter_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/terraform-provider-coder/v2/provider"
@@ -686,6 +687,108 @@ data "coder_parameter" "region" {
 	}
 }
 
+func TestParameterValidation(t *testing.T) {
+	t.Parallel()
+	opts := func(vals ...string) []provider.Option {
+		options := make([]provider.Option, 0, len(vals))
+		for _, val := range vals {
+			options = append(options, provider.Option{
+				Name:  val,
+				Value: val,
+			})
+		}
+		return options
+	}
+
+	for _, tc := range []struct {
+		Name        string
+		Parameter   provider.Parameter
+		Value       string
+		ExpectError *regexp.Regexp
+	}{
+		{
+			Name: "ValidStringParameter",
+			Parameter: provider.Parameter{
+				Type: "string",
+			},
+			Value: "alpha",
+		},
+		// Test invalid states
+		{
+			Name: "InvalidFormType",
+			Parameter: provider.Parameter{
+				Type:     "string",
+				Option:   opts("alpha", "bravo", "charlie"),
+				FormType: provider.ParameterFormTypeSlider,
+			},
+			Value:       "alpha",
+			ExpectError: regexp.MustCompile("Invalid form_type for parameter"),
+		},
+		{
+			Name: "NotInOptions",
+			Parameter: provider.Parameter{
+				Type:   "string",
+				Option: opts("alpha", "bravo", "charlie"),
+			},
+			Value:       "delta", // not in option set
+			ExpectError: regexp.MustCompile("Value must be a valid option"),
+		},
+		{
+			Name: "NonUniqueOptionNames",
+			Parameter: provider.Parameter{
+				Type:   "string",
+				Option: opts("alpha", "alpha"),
+			},
+			Value:       "alpha",
+			ExpectError: regexp.MustCompile("Option names must be unique"),
+		},
+		{
+			Name: "NonUniqueOptionValues",
+			Parameter: provider.Parameter{
+				Type: "string",
+				Option: []provider.Option{
+					{Name: "Alpha", Value: "alpha"},
+					{Name: "AlphaAgain", Value: "alpha"},
+				},
+			},
+			Value:       "alpha",
+			ExpectError: regexp.MustCompile("Option values must be unique"),
+		},
+		{
+			Name: "IncorrectValueTypeOption",
+			Parameter: provider.Parameter{
+				Type:   "number",
+				Option: opts("not-a-number"),
+			},
+			Value:       "5",
+			ExpectError: regexp.MustCompile("is not a number"),
+		},
+		{
+			Name: "IncorrectValueType",
+			Parameter: provider.Parameter{
+				Type: "number",
+			},
+			Value:       "not-a-number",
+			ExpectError: regexp.MustCompile("Parameter value is not of type \"number\""),
+		},
+	} {
+		tc := tc
+		t.Run(tc.Name, func(t *testing.T) {
+			t.Parallel()
+			diags := tc.Parameter.Valid(tc.Value)
+			if tc.ExpectError != nil {
+				require.True(t, diags.HasError())
+				errMsg := fmt.Sprintf("%+v", diags[0]) // close enough
+				require.Truef(t, tc.ExpectError.MatchString(errMsg), "got: %s", errMsg)
+			} else {
+				if !assert.False(t, diags.HasError()) {
+					t.Logf("got: %+v", diags[0])
+				}
+			}
+		})
+	}
+}
+
 func TestValueValidatesType(t *testing.T) {
 	t.Parallel()
 	for _, tc := range []struct {
@@ -798,6 +901,25 @@ func TestValueValidatesType(t *testing.T) {
 		Value:       `[]`,
 		MinDisabled: true,
 		MaxDisabled: true,
+	}, {
+		Name:        "ValidListOfStrings",
+		Type:        "list(string)",
+		Value:       `["first","second","third"]`,
+		MinDisabled: true,
+		MaxDisabled: true,
+	}, {
+		Name:        "InvalidListOfStrings",
+		Type:        "list(string)",
+		Value:       `["first","second","third"`,
+		MinDisabled: true,
+		MaxDisabled: true,
+		Error:       regexp.MustCompile("is not valid list of strings"),
+	}, {
+		Name:        "EmptyListOfStrings",
+		Type:        "list(string)",
+		Value:       `[]`,
+		MinDisabled: true,
+		MaxDisabled: true,
 	}} {
 		tc := tc
 		t.Run(tc.Name, func(t *testing.T) {
