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>
469 lines
13 KiB
Go
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)
|
|
})
|
|
}
|
|
}
|