Files
coder/coderd/templatebuilder/render_test.go
T
Jeremy RuppelandCoder Agents a93b2258cf refactor(coderd/templatebuilder): parse rendered HCL with hclparse and support multiple agents (#28787)
Part of [DEVEX-556](https://linear.app/codercom/issue/DEVEX-556).

## Summary

Replaces the Template Builder's regex-based extraction of information
from base-template Terraform with an `hclsyntax` parse of the rendered
output, and removes the single-`coder_agent` assumption from the compose
core.

## What changed

- `render.go`: parse rendered Terraform via `hclsyntax.ParseConfig`
instead of regex.
- Added `ExtractedAgent{Name, Reference}` and
`ExtractAgentResourceNames`, which enumerates every `coder_agent` in
declaration order and reads `count`/`for_each` from each block body.
This is robust to nested blocks (`env {}`, `metadata {}`), fixing a case
the old `[^}]*` regex missed.
- Kept singular `ExtractAgentResourceName` as a compatibility wrapper
that still errors unless exactly one agent exists.
- `ExtractModuleNames` now walks parsed `module` blocks rather than
line-anchored regex.
- `compose.go`: `Compose` wires modules to the base's first/default
agent instead of erroring when a base declares multiple agents.
Single-agent output is byte-identical.
- `render_test.go`: added `TestExtractAgentResourceNames`
(multiple-in-order, `count` after a nested block, no agents).

## Scope

Parsing/compose layer only. Per-module agent **selection** (SDK/UI) is
intentionally out of scope and left as follow-up.

## Testing

- `go test ./coderd/templatebuilder/` passes (golden snapshots
unchanged).
- `golangci-lint run ./coderd/templatebuilder/` reports 0 issues.
- `go build ./coderd/...` succeeds. No new dependencies
(`hashicorp/hcl/v2` already vendored).

<details>
<summary>Design context</summary>

- The `.tf.tmpl` files are Go templates and only become valid HCL after
rendering, so parsing happens on rendered output (which the extractors
already operated on).
- `base.json` stays authoritative; no manifest fields are inferred or
removed here. A survey found `os` is mostly inferable from
`coder_agent.os` (except `scratch`, which uses a dynamic
`data.coder_provisioner.me.os`), and that `variables` cannot be safely
inferred because base variables are Go-template inputs, not Terraform
`variable` blocks. These were left out to keep the change minimal.
- Multiple agents are supported by wiring modules to the first agent in
document order; single-agent bases are unaffected because first == only.

</details>

---
🤖 Generated with Coder Agents on behalf of @jeremyruppel.

---------

Co-authored-by: Coder Agents <agents@coder.com>
2026-08-31 16:59:36 -04:00

469 lines
13 KiB
Go

package templatebuilder_test
import (
"flag"
"fmt"
"os"
"path/filepath"
"testing"
"testing/fstest"
"github.com/stretchr/testify/require"
"github.com/coder/coder/v2/coderd/templatebuilder"
)
var updateGolden = flag.Bool("update", false, "update golden files")
// testRenderContext builds a BaseRenderContext from defaults and fills
// in deterministic test values for any required variables that have no
// default. This keeps the all-bases test loops working without silently
// producing broken HCL.
func testRenderContext(exampleID string) templatebuilder.BaseRenderContext {
rc := templatebuilder.DefaultBaseRenderContext(exampleID)
if rc.Variables == nil {
rc.Variables = make(map[string]string)
}
for _, v := range templatebuilder.BaseVariables(exampleID) {
if v.Computed || v.Sensitive {
continue
}
if _, ok := rc.Variables[v.Name]; !ok {
rc.Variables[v.Name] = fmt.Sprintf("%q", "test-"+v.Name)
}
}
return rc
}
func TestRenderBaseTemplate(t *testing.T) {
t.Parallel()
t.Run("UnknownBase", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.RenderBaseTemplate("nonexistent", "main.tf.tmpl", templatebuilder.BaseRenderContext{})
require.Error(t, err)
require.Contains(t, err.Error(), "unknown base template")
})
t.Run("InvalidPath", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.RenderBaseTemplate("docker", "nonexistent.tf.tmpl", templatebuilder.BaseRenderContext{})
require.Error(t, err)
require.Contains(t, err.Error(), "not found")
})
imageOpts := []templatebuilder.ImageOption{
{Name: "Ubuntu", Value: "codercom/enterprise-base:ubuntu"},
{Name: "Custom", Value: "custom/image:latest"},
}
t.Run("DockerWithImageOptions", func(t *testing.T) {
t.Parallel()
renderCtx := templatebuilder.BaseRenderContext{
ContainerImage: "custom/image:latest",
ImageOptions: imageOpts,
}
out, err := templatebuilder.RenderBaseTemplate("docker", "main.tf.tmpl", renderCtx)
require.NoError(t, err)
rendered := string(out)
require.Contains(t, rendered, `data.coder_parameter.container_image.value`)
require.Contains(t, rendered, `name = "Ubuntu"`)
require.Contains(t, rendered, `name = "Custom"`)
require.Contains(t, rendered, `coder_parameter`)
})
t.Run("KubernetesWithImageOptions", func(t *testing.T) {
t.Parallel()
renderCtx := templatebuilder.BaseRenderContext{
ContainerImage: "custom/image:latest",
ImageOptions: imageOpts,
Variables: map[string]string{
"namespace": `"test-ns"`,
"use_kubeconfig": "false",
},
}
out, err := templatebuilder.RenderBaseTemplate("kubernetes", "main.tf.tmpl", renderCtx)
require.NoError(t, err)
rendered := string(out)
require.Contains(t, rendered, `data.coder_parameter.container_image.value`)
require.Contains(t, rendered, `name = "Ubuntu"`)
require.Contains(t, rendered, `coder_parameter`)
})
// MissingKeyErrors is tested via RenderModuleTemplate since base templates
// are pre-parsed from the embedded catalog and cannot use ad-hoc filesystems.
}
func TestRenderModuleTemplate(t *testing.T) {
t.Parallel()
t.Run("InvalidPath", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{}
_, err := templatebuilder.RenderModuleTemplate(fsys, "missing.tf.tmpl", templatebuilder.ModuleRenderContext{})
require.Error(t, err)
require.Contains(t, err.Error(), "read template")
})
t.Run("RendersAllFields", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"test.tf.tmpl": &fstest.MapFile{
Data: []byte(`module "test" {
source = "{{ .RegistryBase }}/coder/test/coder"
version = "{{ .PinnedVersion }}"
agent_id = coder_agent.{{ .AgentResourceName }}.id
port = {{ .Variables.port }}
}
`),
},
}
ctx := templatebuilder.ModuleRenderContext{
RegistryBase: "registry.coder.com",
PinnedVersion: "1.5.0",
AgentResourceName: "main",
Variables: map[string]string{"port": "8080"},
}
out, err := templatebuilder.RenderModuleTemplate(fsys, "test.tf.tmpl", ctx)
require.NoError(t, err)
rendered := string(out)
require.Contains(t, rendered, `"registry.coder.com/coder/test/coder"`)
require.Contains(t, rendered, `"1.5.0"`)
require.Contains(t, rendered, `coder_agent.main.id`)
require.Contains(t, rendered, `port = 8080`)
})
t.Run("NilVariablesDoesNotPanic", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"test.tf.tmpl": &fstest.MapFile{
Data: []byte(`module "test" {
source = "{{ .RegistryBase }}"
}
`),
},
}
out, err := templatebuilder.RenderModuleTemplate(fsys, "test.tf.tmpl", templatebuilder.ModuleRenderContext{
RegistryBase: "registry.coder.com",
})
require.NoError(t, err)
require.Contains(t, string(out), "registry.coder.com")
})
t.Run("MissingKeyErrors", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"test.tf.tmpl": &fstest.MapFile{
Data: []byte(`{{ .Variables.missing_key }}`),
},
}
_, err := templatebuilder.RenderModuleTemplate(fsys, "test.tf.tmpl", templatebuilder.ModuleRenderContext{
Variables: map[string]string{"other": "value"},
})
require.Error(t, err)
require.Contains(t, err.Error(), "execute template")
})
t.Run("ParseError", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bad.tf.tmpl": &fstest.MapFile{
Data: []byte(`{{ .Invalid {{ syntax`),
},
}
_, err := templatebuilder.RenderModuleTemplate(fsys, "bad.tf.tmpl", templatebuilder.ModuleRenderContext{})
require.Error(t, err)
require.Contains(t, err.Error(), "parse template")
})
t.Run("RealModuleTemplate", func(t *testing.T) {
t.Parallel()
modules, err := templatebuilder.LoadModules()
require.NoError(t, err)
var csMod templatebuilder.ModuleManifest
for _, m := range modules {
if m.ID == "code-server" {
csMod = m
break
}
}
require.NotEmpty(t, csMod.ID, "code-server module must exist")
fsys, err := templatebuilder.ModuleTemplateFS(csMod.ID)
require.NoError(t, err)
vars := make(map[string]string)
for _, v := range csMod.Variables {
if !v.Computed && !v.Sensitive {
vars[v.Name] = `"test-value"`
}
}
ctx := templatebuilder.ModuleRenderContext{
RegistryBase: "registry.coder.com",
PinnedVersion: csMod.PinnedVersion,
AgentResourceName: "main",
Variables: vars,
}
out, err := templatebuilder.RenderModuleTemplate(fsys, csMod.ID+".tf.tmpl", ctx)
require.NoError(t, err)
rendered := string(out)
require.Contains(t, rendered, `module "code-server"`)
require.Contains(t, rendered, `coder_agent.main.id`)
require.Contains(t, rendered, csMod.PinnedVersion)
})
}
func TestExtractAgentResourceName(t *testing.T) {
t.Parallel()
t.Run("DockerBase", func(t *testing.T) {
t.Parallel()
rendered, err := templatebuilder.RenderBaseTemplate("docker", "main.tf.tmpl", templatebuilder.DefaultBaseRenderContext("docker"))
require.NoError(t, err)
name, err := templatebuilder.ExtractAgentResourceName(rendered)
require.NoError(t, err)
require.Equal(t, "main", name)
})
t.Run("AWSLinuxBase", func(t *testing.T) {
t.Parallel()
rendered, err := templatebuilder.RenderBaseTemplate("aws-linux", "main.tf.tmpl", templatebuilder.DefaultBaseRenderContext("aws-linux"))
require.NoError(t, err)
name, err := templatebuilder.ExtractAgentResourceName(rendered)
require.NoError(t, err)
require.Equal(t, "dev[0]", name, "counted agent should include index")
})
t.Run("CountedAgent", func(t *testing.T) {
t.Parallel()
hcl := []byte(`resource "coder_agent" "myagent" {
count = data.coder_workspace.me.start_count
arch = "amd64"
}`)
name, err := templatebuilder.ExtractAgentResourceName(hcl)
require.NoError(t, err)
require.Equal(t, "myagent[0]", name)
})
t.Run("UncountedAgent", func(t *testing.T) {
t.Parallel()
hcl := []byte(`resource "coder_agent" "main" {
arch = "amd64"
}`)
name, err := templatebuilder.ExtractAgentResourceName(hcl)
require.NoError(t, err)
require.Equal(t, "main", name)
})
t.Run("NoAgent", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.ExtractAgentResourceName([]byte(`resource "docker_container" "workspace" {}`))
require.Error(t, err)
require.Contains(t, err.Error(), "no coder_agent")
})
t.Run("MultipleAgents", func(t *testing.T) {
t.Parallel()
hcl := []byte(`
resource "coder_agent" "first" {}
resource "coder_agent" "second" {}
`)
_, err := templatebuilder.ExtractAgentResourceName(hcl)
require.Error(t, err)
require.Contains(t, err.Error(), "expected exactly one")
require.Contains(t, err.Error(), "found 2")
})
t.Run("NilInput", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.ExtractAgentResourceName(nil)
require.Error(t, err)
require.Contains(t, err.Error(), "no coder_agent")
})
t.Run("EmptyInput", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.ExtractAgentResourceName([]byte{})
require.Error(t, err)
require.Contains(t, err.Error(), "no coder_agent")
})
}
func TestExtractAgentResourceNames(t *testing.T) {
t.Parallel()
t.Run("MultipleInOrder", func(t *testing.T) {
t.Parallel()
hcl := []byte(`
resource "coder_agent" "main" {
os = "linux"
}
resource "coder_agent" "gpu" {
os = "linux"
metadata {
key = "gpu"
}
}
`)
agents, err := templatebuilder.ExtractAgentResourceNames(hcl)
require.NoError(t, err)
require.Equal(t, []templatebuilder.ExtractedAgent{
{Name: "main", Reference: "main"},
{Name: "gpu", Reference: "gpu"},
}, agents)
})
t.Run("CountAfterNestedBlock", func(t *testing.T) {
t.Parallel()
// count declared after a nested block: the reference must still be
// indexed, which the previous regex missed.
hcl := []byte(`resource "coder_agent" "dev" {
os = "linux"
metadata {
key = "cpu"
}
count = data.coder_workspace.me.start_count
}`)
agents, err := templatebuilder.ExtractAgentResourceNames(hcl)
require.NoError(t, err)
require.Equal(t, []templatebuilder.ExtractedAgent{
{Name: "dev", Reference: "dev[0]"},
}, agents)
})
t.Run("NoAgents", func(t *testing.T) {
t.Parallel()
agents, err := templatebuilder.ExtractAgentResourceNames(
[]byte(`resource "docker_container" "workspace" {}`))
require.NoError(t, err)
require.Empty(t, agents)
})
}
// TestExtractModuleNames covers the module block extractor on the
// shapes it must handle for our curated templates: real blocks in declaration
// order, and commented-out blocks ignored because the HCL parser does not
// treat comments as blocks.
func TestExtractModuleNames(t *testing.T) {
t.Parallel()
t.Run("MultipleInOrder", func(t *testing.T) {
t.Parallel()
src := []byte(`module "git-clone" {
source = "registry.coder.com/coder/git-clone/coder"
}
module "code-server" {
source = "registry.coder.com/coder/code-server/coder"
}
`)
require.Equal(t, []string{"git-clone", "code-server"},
templatebuilder.ExtractModuleNames(src))
})
t.Run("IgnoresCommentedBlock", func(t *testing.T) {
t.Parallel()
src := []byte(`module "git-clone" {
source = "registry.coder.com/coder/git-clone/coder"
}
# module "commented" {
# source = "registry.coder.com/coder/commented/coder"
# }
`)
require.Equal(t, []string{"git-clone"}, templatebuilder.ExtractModuleNames(src))
})
t.Run("NoModules", func(t *testing.T) {
t.Parallel()
require.Empty(t, templatebuilder.ExtractModuleNames(
[]byte(`resource "coder_agent" "main" {}`)))
})
}
func TestModuleTemplateFS(t *testing.T) {
t.Parallel()
t.Run("ValidModule", func(t *testing.T) {
t.Parallel()
fsys, err := templatebuilder.ModuleTemplateFS("code-server")
require.NoError(t, err)
require.NotNil(t, fsys)
})
t.Run("UnknownModule", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.ModuleTemplateFS("nonexistent-module")
require.Error(t, err)
require.Contains(t, err.Error(), "not found in embedded catalog")
})
}
func TestAllBasesRenderAndExtractAgent(t *testing.T) {
t.Parallel()
for _, id := range templatebuilder.BaseTemplateIDs() {
t.Run(id, func(t *testing.T) {
t.Parallel()
renderCtx := testRenderContext(id)
rendered, err := templatebuilder.RenderBaseTemplate(id, "main.tf.tmpl", renderCtx)
require.NoError(t, err, "base %q should render without error", id)
require.NotEmpty(t, rendered)
name, err := templatebuilder.ExtractAgentResourceName(rendered)
require.NoError(t, err, "base %q should have exactly one coder_agent", id)
require.NotEmpty(t, name)
})
}
}
func TestBaseTemplateSnapshot(t *testing.T) {
t.Parallel()
tests := []struct {
exampleID string
}{
{exampleID: "docker"},
{exampleID: "kubernetes"},
{exampleID: "aws-linux"},
{exampleID: "aws-windows"},
{exampleID: "azure-linux"},
{exampleID: "digitalocean-linux"},
{exampleID: "gcp-linux"},
{exampleID: "gcp-windows"},
{exampleID: "quickstart"},
{exampleID: "scratch"},
}
for _, tc := range tests {
t.Run(tc.exampleID, func(t *testing.T) {
t.Parallel()
renderCtx := testRenderContext(tc.exampleID)
rendered, err := templatebuilder.RenderBaseTemplate(tc.exampleID, "main.tf.tmpl", renderCtx)
require.NoError(t, err)
require.NotEmpty(t, rendered)
goldenPath := filepath.Join("testdata", tc.exampleID+".tf.golden")
if *updateGolden {
err := os.MkdirAll("testdata", 0o755)
require.NoError(t, err)
err = os.WriteFile(goldenPath, rendered, 0o600)
require.NoError(t, err)
return
}
expected, err := os.ReadFile(goldenPath)
require.NoError(t, err, "golden file %s not found; run with -update to create", goldenPath)
require.Equal(t, string(expected), string(rendered),
"rendered output for %s does not match golden file; run with -update to regenerate", tc.exampleID)
})
}
}