fix: validate that parameter names are unique

code-asher · code-asher · commit 15daad145c35 · 2023-06-06T14:39:57.000-08:00
diff --git a/coderd/util/slice/slice.go b/coderd/util/slice/slice.go
@@ -1,5 +1,10 @@
 package slice
 
+import (
+	"fmt"
+	"strings"
+)
+
 // SameElements returns true if the 2 lists have the same elements in any
 // order.
 func SameElements[T comparable](a []T, b []T) bool {
@@ -67,3 +72,16 @@ func OverlapCompare[T any](a []T, b []T, equal func(a, b T) bool) bool {
 func New[T any](items ...T) []T {
 	return items
 }
+
+// JoinWithConjunction joins a slice of strings with commas except for the last
+// two which are joined with "and".
+func JoinWithConjunction(s []string) string {
+	last := len(s) - 1
+	if last == 0 {
+		return s[last]
+	}
+	return fmt.Sprintf("%s and %s",
+		strings.Join(s[:last], ", "),
+		s[last],
+	)
+}
diff --git a/coderd/util/slice/slice_test.go b/coderd/util/slice/slice_test.go
@@ -83,6 +83,13 @@ func TestOverlap(t *testing.T) {
 	)
 }
 
+func TestJoinWithConjunction(t *testing.T) {
+	t.Parallel()
+	require.Equal(t, "foo", slice.JoinWithConjunction([]string{"foo"}))
+	require.Equal(t, "foo and bar", slice.JoinWithConjunction([]string{"foo", "bar"}))
+	require.Equal(t, "foo, bar and baz", slice.JoinWithConjunction([]string{"foo", "bar", "baz"}))
+}
+
 func assertSetOverlaps[T comparable](t *testing.T, overlap bool, a []T, b []T) {
 	t.Helper()
 	for _, e := range a {
diff --git a/provisioner/terraform/resources.go b/provisioner/terraform/resources.go
@@ -1,6 +1,7 @@
 package terraform
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/awalterschulze/gographviz"
@@ -10,6 +11,7 @@ import (
 
 	"github.com/coder/terraform-provider-coder/provider"
 
+	"github.com/coder/coder/coderd/util/slice"
 	"github.com/coder/coder/codersdk"
 	"github.com/coder/coder/provisioner"
 	"github.com/coder/coder/provisionersdk/proto"
@@ -473,6 +475,7 @@ func ConvertState(modules []*tfjson.StateModule, rawGraph string, rawParameterNa
 		}
 	}
 
+	var duplicatedNames []string
 	parameters := make([]*proto.RichParameter, 0)
 	for _, resource := range orderedRichParametersResources(tfResourcesRichParameters, rawParameterNames) {
 		var param provider.Parameter
@@ -536,9 +539,32 @@ func ConvertState(modules []*tfjson.StateModule, rawGraph string, rawParameterNa
 				})
 			}
 		}
+
+		// Check if this parameter duplicates an existing parameter.
+		formattedName := fmt.Sprintf("%q", protoParam.Name)
+		if !slice.Contains(duplicatedNames, formattedName) &&
+			slice.ContainsCompare(parameters, protoParam, func(a, b *proto.RichParameter) bool {
+				return a.Name == b.Name
+			}) {
+			duplicatedNames = append(duplicatedNames, formattedName)
+		}
+
 		parameters = append(parameters, protoParam)
 	}
 
+	// Enforce that parameters must be uniquely named.
+	if len(duplicatedNames) > 0 {
+		s := ""
+		if len(duplicatedNames) == 1 {
+			s = "s"
+		}
+		return nil, xerrors.Errorf(
+			"coder_parameter names must be unique but %s appear%s multiple times",
+			slice.JoinWithConjunction(duplicatedNames),
+			s,
+		)
+	}
+
 	// A map is used to ensure we don't have duplicates!
 	gitAuthProvidersMap := map[string]struct{}{}
 	for _, tfResources := range tfResourcesByLabel {
diff --git a/provisioner/terraform/resources_test.go b/provisioner/terraform/resources_test.go
@@ -2,6 +2,7 @@ package terraform_test
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -584,6 +585,69 @@ func TestAppSlugValidation(t *testing.T) {
 	require.ErrorContains(t, err, "duplicate app slug")
 }
 
+func TestParameterValidation(t *testing.T) {
+	t.Parallel()
+
+	// nolint:dogsled
+	_, filename, _, _ := runtime.Caller(0)
+
+	// Load the rich-parameters state file and edit it.
+	dir := filepath.Join(filepath.Dir(filename), "testdata", "rich-parameters")
+	tfPlanRaw, err := os.ReadFile(filepath.Join(dir, "rich-parameters.tfplan.json"))
+	require.NoError(t, err)
+	var tfPlan tfjson.Plan
+	err = json.Unmarshal(tfPlanRaw, &tfPlan)
+	require.NoError(t, err)
+	tfPlanGraph, err := os.ReadFile(filepath.Join(dir, "rich-parameters.tfplan.dot"))
+	require.NoError(t, err)
+
+	// Change all names to be identical.
+	var names []string
+	for _, resource := range tfPlan.PriorState.Values.RootModule.Resources {
+		if resource.Type == "coder_parameter" {
+			resource.AttributeValues["name"] = "identical"
+			names = append(names, resource.Name)
+		}
+	}
+
+	state, err := terraform.ConvertState([]*tfjson.StateModule{tfPlan.PriorState.Values.RootModule}, string(tfPlanGraph), names)
+	require.Nil(t, state)
+	require.Error(t, err)
+	require.ErrorContains(t, err, "coder_parameter names must be unique but \"identical\" appears multiple times")
+
+	// Make two sets of identical names.
+	count := 0
+	names = nil
+	for _, resource := range tfPlan.PriorState.Values.RootModule.Resources {
+		if resource.Type == "coder_parameter" {
+			resource.AttributeValues["name"] = fmt.Sprintf("identical-%d", count%2)
+			names = append(names, resource.Name)
+			count++
+		}
+	}
+
+	state, err = terraform.ConvertState([]*tfjson.StateModule{tfPlan.PriorState.Values.RootModule}, string(tfPlanGraph), names)
+	require.Nil(t, state)
+	require.Error(t, err)
+	require.ErrorContains(t, err, "coder_parameter names must be unique but \"identical-0\" and \"identical-1\" appear multiple times")
+
+	// Once more with three sets.
+	count = 0
+	names = nil
+	for _, resource := range tfPlan.PriorState.Values.RootModule.Resources {
+		if resource.Type == "coder_parameter" {
+			resource.AttributeValues["name"] = fmt.Sprintf("identical-%d", count%3)
+			names = append(names, resource.Name)
+			count++
+		}
+	}
+
+	state, err = terraform.ConvertState([]*tfjson.StateModule{tfPlan.PriorState.Values.RootModule}, string(tfPlanGraph), names)
+	require.Nil(t, state)
+	require.Error(t, err)
+	require.ErrorContains(t, err, "coder_parameter names must be unique but \"identical-0\", \"identical-1\" and \"identical-2\" appear multiple times")
+}
+
 func TestInstanceTypeAssociation(t *testing.T) {
 	t.Parallel()
 	type tc struct {

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,13 @@ func TestOverlap(t *testing.T) {`
`83`	`83`	`)`
`84`	`84`	`}`
`85`	`85`
	`86`	`+func TestJoinWithConjunction(t *testing.T) {`
	`87`	`+ t.Parallel()`
	`88`	`+ require.Equal(t, "foo", slice.JoinWithConjunction([]string{"foo"}))`
	`89`	`+ require.Equal(t, "foo and bar", slice.JoinWithConjunction([]string{"foo", "bar"}))`
	`90`	`+ require.Equal(t, "foo, bar and baz", slice.JoinWithConjunction([]string{"foo", "bar", "baz"}))`
	`91`	`+}`
	`92`	`+`
`86`	`93`	`func assertSetOverlaps[T comparable](t *testing.T, overlap bool, a []T, b []T) {`
`87`	`94`	`t.Helper()`
`88`	`95`	`for _, e := range a {`