feat: ValidatePresets to validate presets for prebuild use

Author: Emyrk

extract/preset.go

@@ -1,12 +1,34 @@
 package extract
 
 import (
+	"fmt"
+
 	"github.com/aquasecurity/trivy/pkg/iac/terraform"
-	"github.com/coder/preview/types"
 	"github.com/hashicorp/hcl/v2"
+
+	"github.com/coder/preview/types"
 )
 
-func PresetFromBlock(block *terraform.Block) types.Preset {
+func PresetFromBlock(block *terraform.Block) (tfPreset types.Preset) {
+	defer func() {
+		// Extra safety mechanism to ensure that if a panic occurs, we do not break
+		// everything else.
+		if r := recover(); r != nil {
+			tfPreset = types.Preset{
+				PresetData: types.PresetData{
+					Name: block.Label(),
+				},
+				Diagnostics: types.Diagnostics{
+					{
+						Severity: hcl.DiagError,
+						Summary:  "Panic occurred in extracting preset. This should not happen, please report this to Coder.",
+						Detail:   fmt.Sprintf("panic in preset extract: %+v", r),
+					},
+				},
+			}
+		}
+	}()
+
 	p := types.Preset{
 		PresetData: types.PresetData{
 			Parameters: make(map[string]string),
@@ -41,5 +63,13 @@ func PresetFromBlock(block *terraform.Block) types.Preset {
 		p.Default = defaultAttr.Value().True()
 	}
 
+	prebuildBlock := block.GetBlock("prebuilds")
+	if prebuildBlock != nil {
+		p.Prebuild = &types.PrebuildData{
+			// Invalid values will be set to 0
+			Instances: int(optionalInteger(prebuildBlock, "instances")),
+		}
+	}
+
 	return p
 }

preview.go

@@ -68,6 +68,42 @@ func (o Output) MarshalJSON() ([]byte, error) {
 	})
 }
 
+// ValidatePresets will iterate over each preset, validate the inputs as a set,
+// and attach any diagnostics to the preset if there are issues.
+func ValidatePresets(ctx context.Context, input Input, preValid []types.Preset, dir fs.FS) {
+	for i := range preValid {
+		pre := &preValid[i]
+		if pre.Prebuild == nil || pre.Prebuild.Instances <= 0 {
+			// No prebuilds, so presets do not need to be valid without user input
+			continue
+		}
+
+		input.ParameterValues = pre.Parameters
+
+		output, diagnostics := Preview(ctx, input, dir)
+		if diagnostics.HasErrors() {
+			pre.Diagnostics = append(pre.Diagnostics, diagnostics...)
+		}
+
+		if output == nil {
+			continue
+		}
+
+		for _, param := range output.Parameters {
+			if hcl.Diagnostics(param.Diagnostics).HasErrors() {
+				for _, paramDiag := range param.Diagnostics {
+					if paramDiag.Severity != hcl.DiagError {
+						continue // Only care about errors here
+					}
+					orig := paramDiag.Summary
+					paramDiag.Summary = fmt.Sprintf("Parameter %s: %s", param.Name, orig)
+					pre.Diagnostics = append(pre.Diagnostics, paramDiag)
+				}
+			}
+		}
+	}
+}
+
 func Preview(ctx context.Context, input Input, dir fs.FS) (output *Output, diagnostics 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
@@ -180,7 +216,9 @@ 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)
+	// preValidPresets are extracted as written in terraform. Each individual
+	// param value is checked, however the preset as a whole might not valid.
+	preValidPresets := presets(modules, rp)
 	tags, tagDiags := workspaceTags(modules, p.Files())
 	vars := variables(modules)
 
@@ -191,7 +229,7 @@ func Preview(ctx context.Context, input Input, dir fs.FS) (output *Output, diagn
 		ModuleOutput:  outputs,
 		Parameters:    rp,
 		WorkspaceTags: tags,
-		Presets:       presets,
+		Presets:       preValidPresets,
 		Files:         p.Files(),
 		Variables:     vars,
 	}, diags.Extend(rpDiags).Extend(tagDiags)

preview_test.go

@@ -700,6 +700,55 @@ func Test_Extract(t *testing.T) {
 	}
 }
 
+func TestPresetValidation(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		name         string
+		dir          string
+		input        preview.Input
+		presetAssert map[string]assertPreset
+	}{
+		{
+			name:  "preset failure",
+			dir:   "presetfail",
+			input: preview.Input{},
+			presetAssert: map[string]assertPreset{
+				"invalid_parameters": aPreWithDiags().
+					errorDiagnostics("Parameter no_default: Required parameter not provided"),
+				"valid_preset": aPre().
+					value("has_default", "changed").
+					value("no_default", "custom value").
+					noDiagnostics(),
+				"prebuild_instance_zero": aPre(),
+				"not_prebuild":           aPre(),
+			},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			dirFs := os.DirFS(filepath.Join("testdata", tc.dir))
+			output, diags := preview.Preview(context.Background(), tc.input, dirFs)
+			if diags.HasErrors() {
+				t.Logf("diags: %s", diags)
+			}
+			require.False(t, diags.HasErrors())
+			require.Len(t, diags, 0)
+
+			preview.ValidatePresets(context.Background(), tc.input, output.Presets, dirFs)
+			for _, preset := range output.Presets {
+				check, ok := tc.presetAssert[preset.Name]
+				require.True(t, ok, "unknown preset %s", preset.Name)
+				check(t, preset)
+				delete(tc.presetAssert, preset.Name)
+			}
+
+			require.Len(t, tc.presetAssert, 0, "some presets were not found")
+		})
+	}
+}
+
 type assertVariable func(t *testing.T, variable types.Variable)
 
 func av() assertVariable {
@@ -890,6 +939,71 @@ func (a assertVariable) extend(f assertVariable) assertVariable {
 	}
 }
 
+type assertPreset func(t *testing.T, preset types.Preset)
+
+func aPre() assertPreset {
+	return func(t *testing.T, parameter types.Preset) {
+		t.Helper()
+		assert.Empty(t, parameter.Diagnostics, "parameter should have no diagnostics")
+	}
+}
+
+func aPreWithDiags() assertPreset {
+	return func(t *testing.T, parameter types.Preset) {}
+}
+
+func (a assertPreset) def(def bool) assertPreset {
+	return a.extend(func(t *testing.T, preset types.Preset) {
+		require.Equal(t, def, preset.Default)
+	})
+}
+
+func (a assertPreset) value(key, value string) assertPreset {
+	return a.extend(func(t *testing.T, preset types.Preset) {
+		v, ok := preset.Parameters[key]
+		require.Truef(t, ok, "preset parameter %q existence check", key)
+		assert.Equalf(t, value, v, "preset parameter %q value equality check", key)
+	})
+}
+
+func (a assertPreset) errorDiagnostics(patterns ...string) assertPreset {
+	return a.diagnostics(hcl.DiagError, patterns...)
+}
+
+func (a assertPreset) warnDiagnostics(patterns ...string) assertPreset {
+	return a.diagnostics(hcl.DiagWarning, patterns...)
+}
+
+func (a assertPreset) diagnostics(sev hcl.DiagnosticSeverity, patterns ...string) assertPreset {
+	shadow := patterns
+	return a.extend(func(t *testing.T, preset types.Preset) {
+		t.Helper()
+
+		assertDiags(t, sev, preset.Diagnostics, shadow...)
+	})
+}
+
+func (a assertPreset) noDiagnostics() assertPreset {
+	return a.extend(func(t *testing.T, preset types.Preset) {
+		t.Helper()
+
+		assert.Empty(t, preset.Diagnostics, "parameter should have no diagnostics")
+	})
+}
+
+//nolint:revive
+func (a assertPreset) extend(f assertPreset) assertPreset {
+	if a == nil {
+		a = func(t *testing.T, v types.Preset) {}
+	}
+
+	return func(t *testing.T, v types.Preset) {
+		t.Helper()
+		(a)(t, v)
+		f(t, v)
+	}
+}
+
 func assertDiags(t *testing.T, sev hcl.DiagnosticSeverity, diags types.Diagnostics, patterns ...string) {
 	t.Helper()
 	checks := make([]string, len(patterns))

testdata/presetfail/main.tf

@@ -0,0 +1,51 @@
+terraform {
+  required_providers {
+    coder = {
+      source = "coder/coder"
+      version = "2.8.0"
+    }
+  }
+}
+
+data "coder_parameter" "no_default" {
+  name = "no_default"
+}
+
+data "coder_parameter" "has_default" {
+  name = "has_default"
+  default = "hello world"
+}
+
+
+data "coder_workspace_preset" "invalid_parameters" {
+  name = "invalid_parameters"
+
+  prebuilds {
+    instances = 1
+  }
+}
+
+data "coder_workspace_preset" "valid_preset" {
+  name = "valid_preset"
+
+  parameters = {
+      "no_default" = "custom value"
+      "has_default" = "changed"
+  }
+  prebuilds {
+    instances = 1
+  }
+}
+
+data "coder_workspace_preset" "prebuild_instance_zero" {
+  name = "prebuild_instance_zero"
+
+  prebuilds {
+    // No instances
+    instances = 0
+  }
+}
+
+data "coder_workspace_preset" "not_prebuild" {
+  name = "not_prebuild"
+}

types/preset.go

@@ -11,8 +11,13 @@ type Preset struct {
 	Diagnostics Diagnostics `json:"diagnostics"`
 }
 
+type PrebuildData struct {
+	Instances int `json:"instances"`
+}
+
 type PresetData struct {
 	Name       string            `json:"name"`
 	Parameters map[string]string `json:"parameters"`
 	Default    bool              `json:"default"`
+	Prebuild   *PrebuildData
 }