Files
coder/coderd/dynamicparameters/resolver_test.go
T
Steven Masley d544f394d4 fix(coderd): keep parameter values when the render is incomplete (#29108)
Closes #29099 ([ENG-3324](https://linear.app/codercom/issue/ENG-3324)).
Follow-up to #29102, which stopped the loss propagating through stop
builds but left start builds truncating.

## What this does

A render carrying a `module_not_loaded` diagnostic could not see the
whole template, so a parameter's absence from it is not evidence the
template stopped declaring that parameter. Keep the unmatched values
instead of deleting them.

## Why preserve rather than fail

provisionerd resolves modules itself, so only coderd's render is
degraded. Keeping the value produces a correct apply and the workspace
keeps building. Failing the build would turn silent data loss into an
inability to start every workspace on an affected template version.

A complete render is still authoritative and still narrows the set, so
unrelated warnings and legitimate parameter removals behave exactly as
before.

## Tests

- `TestResolveParameters/IncompleteRender`: complete render drops,
`module_not_loaded` preserves previous and build values, unrelated
warning drops.
- `TestDynamicParametersModuleCachePurged` now continues into the start
build. On `main` it fails with `start build must not drop the module
parameter`.

<details>
<summary>Notes for the reviewer</summary>

### Detection

`preview` tags the warning with `types.DiagnosticCode(diag,
types.DiagnosticModuleNotLoaded)`, so the check is
`previewtypes.ExtractDiagnosticExtra(diag).Code ==
previewtypes.DiagnosticModuleNotLoaded` over the second render's
diagnostics. Adding future completeness codes is a one-line change in
`incompleteRender`.

### Departure from the issue's sketch

The issue proposed also gating on `v.Source != sourceDefault`, to keep
discarding values that only ever came from a default. That check cannot
fire: `sourceDefault` is only assigned to parameters present in the
render output, so an unmatched value is never default-sourced. A default
stored by an earlier build arrives as `sourcePrevious` and is
indistinguishable from user input at this layer. The condition is
omitted rather than left in as dead code.

### Not covered

Nothing surfaces the degraded render to the operator. `wsbuilder` has no
logger, and `render.go` still discards preview's diagnostics (`Logger:
slog.New(slog.DiscardHandler)`). That is the follow-up work listed in
the issue.

</details>

---

🤖 Authored by Coder Agents on behalf of @Emyrk.
2026-09-08 17:20:53 +00:00

384 lines
12 KiB
Go

package dynamicparameters_test
import (
"testing"
"github.com/google/uuid"
"github.com/hashicorp/hcl/v2"
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/dynamicparameters"
"github.com/coder/coder/v2/coderd/dynamicparameters/rendermock"
"github.com/coder/coder/v2/coderd/httpapi/httperror"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/testutil"
"github.com/coder/preview"
previewtypes "github.com/coder/preview/types"
"github.com/coder/terraform-provider-coder/v2/provider"
)
func TestResolveParameters(t *testing.T) {
t.Parallel()
t.Run("NewImmutable", func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
render := rendermock.NewMockRenderer(ctrl)
// A single immutable parameter with no previous value.
render.EXPECT().
Render(gomock.Any(), gomock.Any(), gomock.Any()).
AnyTimes().
Return(&preview.Output{
Parameters: []previewtypes.Parameter{
{
ParameterData: previewtypes.ParameterData{
Name: "immutable",
Type: previewtypes.ParameterTypeString,
FormType: provider.ParameterFormTypeInput,
Mutable: false,
DefaultValue: previewtypes.StringLiteral("foo"),
Required: true,
},
Value: previewtypes.StringLiteral("foo"),
Diagnostics: nil,
},
},
}, nil)
ctx := testutil.Context(t, testutil.WaitShort)
values, err := dynamicparameters.ResolveParameters(ctx, uuid.New(), render, false,
database.WorkspaceTransitionStart,
[]database.WorkspaceBuildParameter{}, // No previous values
[]codersdk.WorkspaceBuildParameter{}, // No new build values
[]database.TemplateVersionPresetParameter{}, // No preset values
)
require.NoError(t, err)
require.Equal(t, map[string]string{"immutable": "foo"}, values)
})
// Tests a parameter going from mutable -> immutable
t.Run("BecameImmutable", func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
render := rendermock.NewMockRenderer(ctrl)
mutable := previewtypes.ParameterData{
Name: "immutable",
Type: previewtypes.ParameterTypeString,
FormType: provider.ParameterFormTypeInput,
Mutable: true,
DefaultValue: previewtypes.StringLiteral("foo"),
Required: true,
}
immutable := mutable
immutable.Mutable = false
// A single immutable parameter with no previous value.
render.EXPECT().
Render(gomock.Any(), gomock.Any(), gomock.Any()).
// Return the mutable param first
Return(&preview.Output{
Parameters: []previewtypes.Parameter{
{
ParameterData: mutable,
Value: previewtypes.StringLiteral("foo"),
Diagnostics: nil,
},
},
}, nil)
render.EXPECT().
Render(gomock.Any(), gomock.Any(), gomock.Any()).
// Then the immutable param
Return(&preview.Output{
Parameters: []previewtypes.Parameter{
{
ParameterData: immutable,
// The user set the value to bar
Value: previewtypes.StringLiteral("bar"),
Diagnostics: nil,
},
},
}, nil)
ctx := testutil.Context(t, testutil.WaitShort)
_, err := dynamicparameters.ResolveParameters(ctx, uuid.New(), render, false,
database.WorkspaceTransitionStart,
[]database.WorkspaceBuildParameter{
{Name: "immutable", Value: "foo"}, // Previous value foo
},
[]codersdk.WorkspaceBuildParameter{
{Name: "immutable", Value: "bar"}, // New value
},
[]database.TemplateVersionPresetParameter{}, // No preset values
)
require.Error(t, err)
resp, ok := httperror.IsResponder(err)
require.True(t, ok)
_, respErr := resp.Response()
require.Len(t, respErr.Validations, 1)
require.Contains(t, respErr.Validations[0].Error(), "is not mutable")
})
t.Run("Monotonic", func(t *testing.T) {
t.Parallel()
tests := []struct {
name string
monotonic string
prev string // empty means no previous value
cur string
firstBuild bool
expectErr string // empty means no error expected
}{
// Increasing
{name: "increasing/increase allowed", monotonic: "increasing", prev: "5", cur: "10"},
{name: "increasing/same allowed", monotonic: "increasing", prev: "5", cur: "5"},
{name: "increasing/decrease rejected", monotonic: "increasing", prev: "10", cur: "5", expectErr: "must be equal or greater than previous value"},
// Decreasing
{name: "decreasing/decrease allowed", monotonic: "decreasing", prev: "10", cur: "5"},
{name: "decreasing/same allowed", monotonic: "decreasing", prev: "5", cur: "5"},
{name: "decreasing/increase rejected", monotonic: "decreasing", prev: "5", cur: "10", expectErr: "must be equal or lower than previous value"},
// First build, not enforced
{name: "increasing/first build", monotonic: "increasing", cur: "1", firstBuild: true},
// No previous value, not enforced
{name: "increasing/no previous", monotonic: "increasing", cur: "5"},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
render := rendermock.NewMockRenderer(ctrl)
render.EXPECT().
Render(gomock.Any(), gomock.Any(), gomock.Any()).
AnyTimes().
Return(&preview.Output{
Parameters: []previewtypes.Parameter{
{
ParameterData: previewtypes.ParameterData{
Name: "param",
Type: previewtypes.ParameterTypeNumber,
FormType: provider.ParameterFormTypeInput,
Mutable: true,
Validations: []*previewtypes.ParameterValidation{
{Monotonic: new(tc.monotonic)},
},
},
Value: previewtypes.StringLiteral(tc.cur),
Diagnostics: nil,
},
},
}, nil)
var previousValues []database.WorkspaceBuildParameter
if tc.prev != "" {
previousValues = []database.WorkspaceBuildParameter{
{Name: "param", Value: tc.prev},
}
}
ctx := testutil.Context(t, testutil.WaitShort)
_, err := dynamicparameters.ResolveParameters(ctx, uuid.New(), render, tc.firstBuild,
database.WorkspaceTransitionStart,
previousValues,
[]codersdk.WorkspaceBuildParameter{
{Name: "param", Value: tc.cur},
},
[]database.TemplateVersionPresetParameter{},
)
if tc.expectErr != "" {
require.Error(t, err)
resp, ok := httperror.IsResponder(err)
require.True(t, ok)
_, respErr := resp.Response()
require.Len(t, respErr.Validations, 1)
require.Contains(t, respErr.Validations[0].Error(), tc.expectErr)
} else {
require.NoError(t, err)
}
})
}
})
// A render that omits a parameter the workspace already has a value for must
// not discard that value on a stop or delete build. Only a start build may
// narrow the stored set. See https://github.com/coder/coder/issues/29099.
t.Run("UnmatchedValues", func(t *testing.T) {
t.Parallel()
tests := []struct {
transition database.WorkspaceTransition
expect map[string]string
}{
{
transition: database.WorkspaceTransitionStart,
expect: map[string]string{"rendered": "foo"},
},
{
transition: database.WorkspaceTransitionStop,
expect: map[string]string{"rendered": "foo", "unrendered": "1000Gi"},
},
{
transition: database.WorkspaceTransitionDelete,
expect: map[string]string{"rendered": "foo", "unrendered": "1000Gi"},
},
}
for _, tc := range tests {
t.Run(string(tc.transition), func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
render := rendermock.NewMockRenderer(ctrl)
// The render only knows about "rendered". "unrendered" is absent,
// as it would be if it came from a module that failed to load.
render.EXPECT().
Render(gomock.Any(), gomock.Any(), gomock.Any()).
AnyTimes().
Return(&preview.Output{
Parameters: []previewtypes.Parameter{
{
ParameterData: previewtypes.ParameterData{
Name: "rendered",
Type: previewtypes.ParameterTypeString,
FormType: provider.ParameterFormTypeInput,
Mutable: true,
},
Value: previewtypes.StringLiteral("foo"),
Diagnostics: nil,
},
},
}, nil)
ctx := testutil.Context(t, testutil.WaitShort)
values, err := dynamicparameters.ResolveParameters(ctx, uuid.New(), render, false,
tc.transition,
[]database.WorkspaceBuildParameter{
{Name: "rendered", Value: "foo"},
{Name: "unrendered", Value: "1000Gi"},
},
[]codersdk.WorkspaceBuildParameter{},
[]database.TemplateVersionPresetParameter{},
)
require.NoError(t, err)
require.Equal(t, tc.expect, values)
})
}
})
// An incomplete render omits parameters the template still declares, so the
// values behind them must survive a start build.
// See https://github.com/coder/coder/issues/29099.
t.Run("IncompleteRender", func(t *testing.T) {
t.Parallel()
tests := []struct {
name string
diags hcl.Diagnostics
previous []database.WorkspaceBuildParameter
build []codersdk.WorkspaceBuildParameter
expect map[string]string
}{
{
// A complete render is authoritative, so the value is still dropped.
name: "complete render drops",
previous: []database.WorkspaceBuildParameter{
{Name: "rendered", Value: "foo"},
{Name: "unrendered", Value: "1000Gi"},
},
expect: map[string]string{"rendered": "foo"},
},
{
name: "module not loaded preserves previous",
diags: hcl.Diagnostics{moduleNotLoadedDiagnostic()},
previous: []database.WorkspaceBuildParameter{
{Name: "rendered", Value: "foo"},
{Name: "unrendered", Value: "1000Gi"},
},
expect: map[string]string{"rendered": "foo", "unrendered": "1000Gi"},
},
{
// A value supplied with this build is user input too.
name: "module not loaded preserves build value",
diags: hcl.Diagnostics{moduleNotLoadedDiagnostic()},
build: []codersdk.WorkspaceBuildParameter{
{Name: "unrendered", Value: "1000Gi"},
},
expect: map[string]string{"rendered": "foo", "unrendered": "1000Gi"},
},
{
// Warnings that say nothing about completeness do not preserve.
name: "unrelated warning drops",
diags: hcl.Diagnostics{{
Severity: hcl.DiagWarning,
Summary: "Some other warning",
}},
previous: []database.WorkspaceBuildParameter{
{Name: "rendered", Value: "foo"},
{Name: "unrendered", Value: "1000Gi"},
},
expect: map[string]string{"rendered": "foo"},
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ctrl := gomock.NewController(t)
render := rendermock.NewMockRenderer(ctrl)
// "unrendered" is never reported by the render.
render.EXPECT().
Render(gomock.Any(), gomock.Any(), gomock.Any()).
AnyTimes().
Return(&preview.Output{
Parameters: []previewtypes.Parameter{
{
ParameterData: previewtypes.ParameterData{
Name: "rendered",
Type: previewtypes.ParameterTypeString,
FormType: provider.ParameterFormTypeInput,
Mutable: true,
DefaultValue: previewtypes.StringLiteral("foo"),
},
Value: previewtypes.StringLiteral("foo"),
Diagnostics: nil,
},
},
}, tc.diags)
ctx := testutil.Context(t, testutil.WaitShort)
values, err := dynamicparameters.ResolveParameters(ctx, uuid.New(), render, false,
database.WorkspaceTransitionStart,
tc.previous,
tc.build,
[]database.TemplateVersionPresetParameter{},
)
require.NoError(t, err)
require.Equal(t, tc.expect, values)
})
}
})
}
// moduleNotLoadedDiagnostic is the warning preview emits when a module block
// cannot be resolved, which is what a missing module cache looks like.
func moduleNotLoadedDiagnostic() *hcl.Diagnostic {
return previewtypes.DiagnosticCode(&hcl.Diagnostic{
Severity: hcl.DiagWarning,
Summary: "Module not loaded. Did you run `terraform init`?",
Detail: "Module 'module \"jetbrains_gateway\"' cannot be resolved. This module will be ignored.",
}, previewtypes.DiagnosticModuleNotLoaded)
}