integrate preset validation into preview.Preview

add tests

Author: SasSwart

extract/parameter.go

@@ -274,15 +274,18 @@ func requiredString(block *terraform.Block, key string) (string, *hcl.Diagnostic
 		}
 
 		diag := &hcl.Diagnostic{
-			Severity: hcl.DiagError,
-			Summary:  fmt.Sprintf("Invalid %q attribute for block %s", key, block.Label()),
-			Detail:   fmt.Sprintf("Expected a string, got %q", typeName),
-			Subject:  &(tyAttr.HCLAttribute().Range),
-			//Context:     &(block.HCLBlock().DefRange),
-			Expression:  tyAttr.HCLAttribute().Expr,
+			Severity:    hcl.DiagError,
+			Summary:     fmt.Sprintf("Invalid %q attribute for block %s", key, block.Label()),
+			Detail:      fmt.Sprintf("Expected a string, got %q", typeName),
 			EvalContext: block.Context().Inner(),
 		}
 
+		if tyAttr.IsNotNil() {
+			diag.Subject = &(tyAttr.HCLAttribute().Range)
+			// diag.Context = &(block.HCLBlock().DefRange)
+			diag.Expression = tyAttr.HCLAttribute().Expr
+		}
+
 		if !tyVal.IsWhollyKnown() {
 			refs := hclext.ReferenceNames(tyAttr.HCLAttribute().Expr)
 			if len(refs) > 0 {

extract/preset.go

@@ -6,26 +6,40 @@ import (
 	"github.com/hashicorp/hcl/v2"
 )
 
-func PresetFromBlock(block *terraform.Block) (*types.Preset, hcl.Diagnostics) {
-	var diags hcl.Diagnostics
-
-	pName, nameDiag := requiredString(block, "name")
-	if nameDiag != nil {
-		diags = append(diags, nameDiag)
-	}
-
+func PresetFromBlock(block *terraform.Block) types.Preset {
 	p := types.Preset{
 		PresetData: types.PresetData{
-			Name:       pName,
 			Parameters: make(map[string]string),
 		},
 		Diagnostics: types.Diagnostics{},
 	}
 
+	if !block.IsResourceType(types.BlockTypePreset) {
+		p.Diagnostics = append(p.Diagnostics, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid Preset",
+			Detail:   "Block is not a preset",
+		})
+		return p
+	}
+
+	pName, nameDiag := requiredString(block, "name")
+	if nameDiag != nil {
+		p.Diagnostics = append(p.Diagnostics, nameDiag)
+	}
+	p.Name = pName
+
+	// GetAttribute and AsMapValue both gracefully handle `nil`, `null` and `unknown` values.
+	// All of these return an empty map, which then makes the loop below a no-op.
 	params := block.GetAttribute("parameters").AsMapValue()
 	for presetParamName, presetParamValue := range params.Value() {
 		p.Parameters[presetParamName] = presetParamValue
 	}
 
-	return &p, diags
+	defaultAttr := block.GetAttribute("default")
+	if defaultAttr != nil {
+		p.Default = defaultAttr.Value().True()
+	}
+
+	return p
 }

preset.go

@@ -11,20 +11,25 @@ import (
 	"github.com/coder/preview/types"
 )
 
-func presets(modules terraform.Modules, parameters []types.Parameter) ([]types.Preset, hcl.Diagnostics) {
-	diags := make(hcl.Diagnostics, 0)
-	presets := make([]types.Preset, 0)
+// presets extracts all presets from the given modules. It then validates the name,
+// parameters and default preset.
+func presets(modules terraform.Modules, parameters []types.Parameter) []types.Preset {
+	foundPresets := make([]types.Preset, 0)
+	var defaultPreset *types.Preset
 
 	for _, mod := range modules {
 		blocks := mod.GetDatasByType(types.BlockTypePreset)
 		for _, block := range blocks {
-			preset, pDiags := extract.PresetFromBlock(block)
-			if len(pDiags) > 0 {
-				diags = diags.Extend(pDiags)
-			}
-
-			if preset == nil {
-				continue
+			preset := extract.PresetFromBlock(block)
+			switch true {
+			case defaultPreset != nil && preset.Default:
+				preset.Diagnostics = append(preset.Diagnostics, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Multiple default presets",
+					Detail:   fmt.Sprintf("Only one preset can be marked as default. %q is already marked as default", defaultPreset.Name),
+				})
+			case defaultPreset == nil && preset.Default:
+				defaultPreset = &preset
 			}
 
 			for paramName, paramValue := range preset.Parameters {
@@ -35,7 +40,7 @@ func presets(modules terraform.Modules, parameters []types.Parameter) ([]types.P
 					preset.Diagnostics = append(preset.Diagnostics, &hcl.Diagnostic{
 						Severity: hcl.DiagError,
 						Summary:  "Undefined Parameter",
-						Detail:   fmt.Sprintf("Preset %q requires parameter %q, but it is not defined by the template.", preset.Name, paramName),
+						Detail:   fmt.Sprintf("Preset parameter %q is not defined by the template.", paramName),
 					})
 					continue
 				}
@@ -45,9 +50,9 @@ func presets(modules terraform.Modules, parameters []types.Parameter) ([]types.P
 				}
 			}
 
-			presets = append(presets, *preset)
+			foundPresets = append(foundPresets, preset)
 		}
 	}
 
-	return presets, diags
+	return foundPresets
 }

preview.go

@@ -38,6 +38,7 @@ type Output struct {
 
 	Parameters    []types.Parameter `json:"parameters"`
 	WorkspaceTags types.TagBlocks   `json:"workspace_tags"`
+	Presets       []types.Preset    `json:"presets"`
 	// Files is included for printing diagnostics.
 	// They can be marshalled, but not unmarshalled. This is a limitation
 	// of the HCL library.
@@ -162,6 +163,7 @@ func Preview(ctx context.Context, input Input, dir fs.FS) (output *Output, diagn
 
 	diags := make(hcl.Diagnostics, 0)
 	rp, rpDiags := parameters(modules)
+	presets := presets(modules, rp)
 	tags, tagDiags := workspaceTags(modules, p.Files())
 
 	// Add warnings
@@ -171,6 +173,7 @@ func Preview(ctx context.Context, input Input, dir fs.FS) (output *Output, diagn
 		ModuleOutput:  outputs,
 		Parameters:    rp,
 		WorkspaceTags: tags,
+		Presets:       presets,
 		Files:         p.Files(),
 	}, diags.Extend(rpDiags).Extend(tagDiags)
 }
@@ -209,70 +212,3 @@ func tfVarFiles(path string, dir fs.FS) ([]string, error) {
 	}
 	return files, nil
 }
-
-func PreviewPresets(ctx context.Context, dir fs.FS) ([]types.Preset, hcl.Diagnostics) {
-	// The trivy package works with `github.com/zclconf/go-cty`. This package is
-	// similar to `reflect` in its usage. This package can panic if types are
-	// misused. To protect the caller, a general `recover` is used to catch any
-	// mistakes. If this happens, there is a developer bug that needs to be resolved.
-	var diagnostics hcl.Diagnostics
-	defer func() {
-		if r := recover(); r != nil {
-			diagnostics.Extend(hcl.Diagnostics{
-				{
-					Severity: hcl.DiagError,
-					Summary:  "Panic occurred in preview. This should not happen, please report this to Coder.",
-					Detail:   fmt.Sprintf("panic in preview: %+v", r),
-				},
-			})
-		}
-	}()
-
-	logger := slog.New(slog.DiscardHandler)
-
-	varFiles, err := tfVarFiles("", dir)
-	if err != nil {
-		return nil, hcl.Diagnostics{
-			{
-				Severity: hcl.DiagError,
-				Summary:  "Files not found",
-				Detail:   err.Error(),
-			},
-		}
-	}
-
-	// moduleSource is "" for a local module
-	p := parser.New(dir, "",
-		parser.OptionWithLogger(logger),
-		parser.OptionStopOnHCLError(false),
-		parser.OptionWithDownloads(false),
-		parser.OptionWithSkipCachedModules(true),
-		parser.OptionWithTFVarsPaths(varFiles...),
-	)
-
-	err = p.ParseFS(ctx, ".")
-	if err != nil {
-		return nil, hcl.Diagnostics{
-			{
-				Severity: hcl.DiagError,
-				Summary:  "Parse terraform files",
-				Detail:   err.Error(),
-			},
-		}
-	}
-
-	modules, err := p.EvaluateAll(ctx)
-	if err != nil {
-		return nil, hcl.Diagnostics{
-			{
-				Severity: hcl.DiagError,
-				Summary:  "Evaluate terraform files",
-				Detail:   err.Error(),
-			},
-		}
-	}
-
-	rp, rpDiags := parameters(modules)
-	presets, presetDiags := presets(modules, rp)
-	return presets, diagnostics.Extend(rpDiags).Extend(presetDiags)
-}

preview_test.go

@@ -42,7 +42,7 @@ func Test_Extract(t *testing.T) {
 		expTags     map[string]string
 		unknownTags []string
 		params      map[string]assertParam
-		presets     []types.Preset
+		presets     func(t *testing.T, presets []types.Preset)
 		warnings    []*regexp.Regexp
 	}{
 		{
@@ -243,6 +243,80 @@ func Test_Extract(t *testing.T) {
 					errorDiagnostics("Required"),
 			},
 		},
+		{
+			name:        "empty preset",
+			dir:         "emptypreset",
+			expTags:     map[string]string{},
+			input:       preview.Input{},
+			unknownTags: []string{},
+			presets: func(t *testing.T, presets []types.Preset) {
+				require.Len(t, presets, 1)
+				preset := presets[0]
+				require.Len(t, preset.Diagnostics, 1)
+				require.Equal(t, preset.Diagnostics[0].Summary, "Invalid \"name\" attribute for block coder_workspace_preset.test")
+				require.Equal(t, preset.Diagnostics[0].Detail, "Expected a string, got \"<nil>\"")
+			},
+			failPreview: false,
+		},
+		{
+			name:        "invalid presets",
+			dir:         "invalidpresets",
+			expTags:     map[string]string{},
+			input:       preview.Input{},
+			unknownTags: []string{},
+			params: map[string]assertParam{
+				"valid_parameter_name": ap().
+					optVals("valid_option_value"),
+			},
+			presets: func(t *testing.T, presets []types.Preset) {
+				presetMap := map[string]func(t *testing.T, preset types.Preset){
+					"": func(t *testing.T, preset types.Preset) {
+						require.Len(t, preset.Diagnostics, 0)
+					},
+					"empty_parameters": func(t *testing.T, preset types.Preset) {
+						require.Len(t, preset.Diagnostics, 0)
+					},
+					"no_parameters": func(t *testing.T, preset types.Preset) {
+						require.Len(t, preset.Diagnostics, 0)
+					},
+					"invalid_parameter_name": func(t *testing.T, preset types.Preset) {
+						require.Len(t, preset.Diagnostics, 1)
+						require.Equal(t, preset.Diagnostics[0].Summary, "Undefined Parameter")
+						require.Equal(t, preset.Diagnostics[0].Detail, "Preset parameter \"invalid_parameter_name\" is not defined by the template.")
+					},
+					"invalid_parameter_value": func(t *testing.T, preset types.Preset) {
+						require.Len(t, preset.Diagnostics, 1)
+						require.Equal(t, preset.Diagnostics[0].Summary, "Value must be a valid option")
+						require.Equal(t, preset.Diagnostics[0].Detail, "the value \"invalid_value\" must be defined as one of options")
+					},
+					"valid_preset": func(t *testing.T, preset types.Preset) {
+						require.Len(t, preset.Diagnostics, 0)
+						require.Equal(t, preset.Parameters, map[string]string{
+							"valid_parameter_name": "valid_option_value",
+						})
+					},
+				}
+
+				for _, preset := range presets {
+					if fn, ok := presetMap[preset.Name]; ok {
+						fn(t, preset)
+					}
+				}
+
+				var defaultPresetsWithError int
+				for _, preset := range presets {
+					if preset.Name == "default_preset" || preset.Name == "another_default_preset" {
+						for _, diag := range preset.Diagnostics {
+							if diag.Summary == "Multiple default presets" {
+								defaultPresetsWithError++
+								break
+							}
+						}
+					}
+				}
+				require.Equal(t, 1, defaultPresetsWithError, "exactly one default preset should have the multiple defaults error")
+			},
+		},
 		{
 			name:        "required",
 			dir:         "required",
@@ -545,8 +619,10 @@ func Test_Extract(t *testing.T) {
 				check(t, param)
 			}
 
-			presets, diags := preview.PreviewPresets(context.Background(), dirFs)
-			assert.ElementsMatch(t, tc.presets, presets)
+			// Assert presets
+			if tc.presets != nil {
+				tc.presets(t, output.Presets)
+			}
 		})
 	}
 }

testdata/emptypreset/main.tf

@@ -0,0 +1,11 @@
+terraform {
+  required_providers {
+    coder = {
+      source = "coder/coder"
+      version = "2.8.0"
+    }
+  }
+}
+
+data "coder_workspace_preset" "test" {
+}