Files
coder/coderd/templatebuilder/compose_test.go
T
Jeremy RuppelandAndrew Aquino 52142e6e94 fix(coderd/templatebuilder): strip prerequisite markers from delivered README (#28953)
## Problem

Template builder base READMEs delimit their prerequisites section with
HTML comment markers (`<!-- prerequisites:start -->` / `<!--
prerequisites:end -->`). `ExtractPrerequisites` uses these to populate
the builder's Prerequisites step, which works correctly.

However, `Compose` embeds the **full** base README verbatim into the
generated template's tarball. Because `react-markdown` renders raw HTML
comments as literal text, the markers were visible when the delivered
README is viewed via `MemoizedMarkdown`.

<img width="876" height="586" alt="Screenshot 2026-09-03 at 3 28 08 PM"
src="https://github.com/user-attachments/assets/70353ee2-1ff6-4e70-9b5d-7ac0521b945f"
/>

## Fix

Strip the prerequisite markers from the README before writing it into
the tarball (Option 2), keeping the change contained to the template
builder and leaving global markdown rendering untouched.

- `prerequisites.go`: new `StripPrerequisiteMarkers` removes each marker
line (plus an optional trailing blank line so no gap is left) while
preserving the content between them.
- `compose.go`: new `composedReadme` helper applies the strip in both
`Compose` return paths; returns `nil` for an empty README, preserving
the existing "omit README.md when empty" behavior.
- `ExtractPrerequisites` still reads the markers from the source
`BaseReadme`, so the builder's Prerequisites step is unaffected.

## Testing

- `TestStripPrerequisiteMarkers` covers both markers, no markers, single
markers, missing trailing blank line, and end-of-file cases.
- Extended the compose test to assert the delivered README contains no
marker text.
- `go test ./coderd/templatebuilder/`, `go vet`, and `golangci-lint run
./coderd/templatebuilder/...` all pass.

<details>
<summary>Approach considered</summary>

Two options were on the table:

1. Skip HTML comments in the shared `MemoizedMarkdown` component (fixes
any stray comment globally, but changes shared rendering behavior
app-wide).
2. Strip the markers from the README before inserting it into the
template zipball (targeted; markers have no purpose in the delivered
README since prerequisites are already extracted separately).

Option 2 was chosen for being contained and easily unit-tested.
</details>

---
_This PR was created by Coder Agents on behalf of @jeremyruppel._

---------

Co-authored-by: Andrew Aquino <dawneraq@gmail.com>
2026-09-04 19:14:10 +00:00

703 lines
23 KiB
Go

package templatebuilder_test
import (
"archive/tar"
"bytes"
"errors"
"io"
"io/fs"
"regexp"
"testing"
"github.com/stretchr/testify/require"
"github.com/coder/coder/v2/coderd/templatebuilder"
)
func TestCompose(t *testing.T) {
t.Parallel()
t.Run("BaseOnly", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.NotEmpty(t, result.MainTF)
require.Contains(t, string(result.MainTF), `resource "coder_agent" "main"`)
require.Empty(t, result.ModulesTF)
require.NotEmpty(t, result.Readme, "compose should include base README")
require.NotContains(t, string(result.Readme), "prerequisites:start",
"delivered README should not contain prerequisites markers")
require.NotContains(t, string(result.Readme), "prerequisites:end",
"delivered README should not contain prerequisites markers")
})
t.Run("BaseWithModuleAndVariableOverride", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{
ID: "code-server",
Variables: map[string]string{
"port": "9999",
},
},
},
})
require.NoError(t, err)
require.NotEmpty(t, result.MainTF)
require.NotEmpty(t, result.ModulesTF)
modules := string(result.ModulesTF)
require.Contains(t, modules, `module "code-server"`)
require.Contains(t, modules, `coder_agent.main.id`)
require.Contains(t, modules, `registry.coder.com`)
require.Regexp(t, `port\s+=\s+9999`, modules)
})
t.Run("AWSLinuxAgentName", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "aws-linux",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "git-commit-signing"},
},
})
require.NoError(t, err)
require.Contains(t, string(result.ModulesTF), `coder_agent.dev[0].id`)
})
t.Run("ExplicitAgentName", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "git-commit-signing", AgentName: "main"},
},
})
require.NoError(t, err)
require.Contains(t, string(result.ModulesTF), `coder_agent.main.id`)
})
t.Run("UnknownAgentName", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "git-commit-signing", AgentName: "nonexistent"},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `unknown agent "nonexistent"`)
})
t.Run("AWSLinuxExtraFiles", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "aws-linux",
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.NotNil(t, result.ExtraFiles, "aws-linux should have extra files")
require.Contains(t, result.ExtraFiles, "cloud-init/cloud-config.yaml.tftpl")
require.Contains(t, result.ExtraFiles, "cloud-init/userdata.sh.tftpl")
})
t.Run("GCPLinuxBaseWithProjectID", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "gcp-linux",
BaseVariableValues: map[string]string{"project_id": "my-gcp-project"},
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.NotEmpty(t, result.MainTF)
mainTF := string(result.MainTF)
require.Contains(t, mainTF, `resource "coder_agent" "main"`)
require.Contains(t, mainTF, `default = "my-gcp-project"`)
require.Contains(t, mainTF, `project = var.project_id`)
})
t.Run("GCPWindowsBase", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "gcp-windows",
BaseVariableValues: map[string]string{"project_id": "my-gcp-project"},
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.NotEmpty(t, result.MainTF)
mainTF := string(result.MainTF)
require.Contains(t, mainTF, `resource "coder_agent" "main"`)
require.Contains(t, mainTF, `default = "my-gcp-project"`)
require.Contains(t, mainTF, `project = var.project_id`)
})
t.Run("GCPMissingRequiredBaseVariable", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "gcp-linux",
RegistryURL: "registry.coder.com",
})
require.Error(t, err)
require.Contains(t, err.Error(), `variable "project_id" is required`)
})
t.Run("AzureLinuxExtraFiles", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "azure-linux",
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.Contains(t, result.ExtraFiles, "cloud-init/cloud-config.yaml.tftpl")
})
t.Run("SensitiveVariable", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "claude-code"},
},
})
require.NoError(t, err)
modules := string(result.ModulesTF)
// claude-code has a sensitive variable (claude_code_oauth_token)
// that renders as a top-level variable block + var. reference.
require.Contains(t, modules, `variable "claude_code_oauth_token"`)
require.Contains(t, modules, `sensitive = true`)
require.Contains(t, modules, `var.claude_code_oauth_token`)
})
t.Run("MultipleModulesWithRequiredVariable", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "code-server"},
{
ID: "git-clone",
Variables: map[string]string{
"url": "https://github.com/coder/coder",
},
},
},
})
require.NoError(t, err)
modules := string(result.ModulesTF)
require.Contains(t, modules, `module "code-server"`)
require.Contains(t, modules, `module "git-clone"`)
require.Contains(t, modules, `"https://github.com/coder/coder"`)
})
t.Run("CustomRegistryURL", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.internal.corp",
Modules: []templatebuilder.ComposeModule{
{ID: "code-server"},
},
})
require.NoError(t, err)
require.Contains(t, string(result.ModulesTF), `registry.internal.corp`)
})
t.Run("DuplicateModuleError", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "code-server"},
{ID: "code-server"},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `duplicate module "code-server"`)
})
t.Run("BaseIncludedModuleCollisionError", func(t *testing.T) {
t.Parallel()
// The quickstart base already declares module "git-clone"; selecting
// the catalog git-clone module in the wizard would render a duplicate
// module block, so compose must reject it.
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "quickstart",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "git-clone"},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `module "git-clone" is already included by this base template`)
})
t.Run("BaseAllowsNonIncludedModule", func(t *testing.T) {
t.Parallel()
// Quickstart only includes git-clone; other catalog modules such as
// code-server compose normally on top of it.
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "quickstart",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "code-server"},
},
})
require.NoError(t, err)
require.Contains(t, string(result.ModulesTF), `module "code-server"`)
})
t.Run("ConflictingModuleError", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "code-server"},
{ID: "vscode-web"},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), "conflicts with")
})
t.Run("DockerNoExtraFiles", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.Empty(t, result.ExtraFiles, "docker should have no extra files")
})
t.Run("UnknownBase", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "nonexistent",
RegistryURL: "registry.coder.com",
})
require.Error(t, err)
require.Contains(t, err.Error(), "unknown base template")
})
t.Run("UnknownModule", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "nonexistent-module"},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `unknown module "nonexistent-module"`)
})
t.Run("UnknownVariableKeyRejected", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{
ID: "code-server",
Variables: map[string]string{
"nonexistent_var": "value",
},
},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `module "code-server"`)
require.Contains(t, err.Error(), `unknown variable "nonexistent_var"`)
})
t.Run("InvalidVariableValueRejected", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{
ID: "code-server",
Variables: map[string]string{
"port": "not-a-number",
},
},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `module "code-server"`)
require.Contains(t, err.Error(), `variable "port"`)
})
t.Run("HCLInjectionRejected", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{
ID: "code-server",
Variables: map[string]string{
"folder": "${var.evil}",
},
},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), "interpolation")
})
t.Run("DockerDefaultContainerImage", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
require.Contains(t, string(result.MainTF), `"codercom/example-base:ubuntu"`)
})
t.Run("DockerCustomContainerImage", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
BaseVariableValues: map[string]string{
"container_image": "myregistry/myimage:v2",
},
})
require.NoError(t, err)
mainTF := string(result.MainTF)
require.Contains(t, mainTF, `"myregistry/myimage:v2"`)
require.NotContains(t, mainTF, `codercom/example-base:ubuntu`)
})
t.Run("KubernetesDefaultContainerImage", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "kubernetes",
RegistryURL: "registry.coder.com",
BaseVariableValues: map[string]string{
"namespace": "default",
},
})
require.NoError(t, err)
require.Contains(t, string(result.MainTF), `"codercom/example-base:ubuntu"`)
})
t.Run("KubernetesCustomContainerImage", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "kubernetes",
RegistryURL: "registry.coder.com",
BaseVariableValues: map[string]string{
"namespace": "default",
"container_image": "custom/workspace:latest",
},
})
require.NoError(t, err)
mainTF := string(result.MainTF)
require.Contains(t, mainTF, `"custom/workspace:latest"`)
require.NotContains(t, mainTF, `codercom/example-base:ubuntu`)
})
t.Run("MissingRequiredVariable", func(t *testing.T) {
t.Parallel()
// git-clone has a required "url" variable with no default.
// Omitting it should cause a render error from missingkey=error.
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "git-clone"},
},
})
require.Error(t, err)
require.Contains(t, err.Error(), `variable "url"`)
require.Contains(t, err.Error(), "is required")
})
}
func TestBundleTar(t *testing.T) {
t.Parallel()
t.Run("NilResult", func(t *testing.T) {
t.Parallel()
_, err := templatebuilder.BundleTar(nil)
require.Error(t, err)
require.Contains(t, err.Error(), "nil")
})
t.Run("MainOnly", func(t *testing.T) {
t.Parallel()
result := &templatebuilder.ComposeResult{
MainTF: []byte("resource {}"),
}
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Contains(t, files, "main.tf")
require.NotContains(t, files, "modules.tf")
require.NotContains(t, files, "README.md")
require.Equal(t, "resource {}", files["main.tf"])
})
t.Run("MainAndModules", func(t *testing.T) {
t.Parallel()
result := &templatebuilder.ComposeResult{
MainTF: []byte("resource {}"),
ModulesTF: []byte("module {}"),
}
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Contains(t, files, "main.tf")
require.Contains(t, files, "modules.tf")
require.NotContains(t, files, "README.md")
require.Equal(t, "resource {}", files["main.tf"])
require.Equal(t, "module {}", files["modules.tf"])
})
t.Run("IncludesReadme", func(t *testing.T) {
t.Parallel()
result := &templatebuilder.ComposeResult{
MainTF: []byte("resource {}"),
Readme: []byte("# My Template\n"),
}
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Contains(t, files, "main.tf")
require.Contains(t, files, "README.md")
require.Equal(t, "# My Template\n", files["README.md"])
})
t.Run("RoundTrip", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "docker",
RegistryURL: "registry.coder.com",
Modules: []templatebuilder.ComposeModule{
{ID: "code-server"},
},
})
require.NoError(t, err)
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Equal(t, string(result.MainTF), files["main.tf"])
require.Equal(t, string(result.ModulesTF), files["modules.tf"])
require.Equal(t, string(result.Readme), files["README.md"])
})
t.Run("ExtraFilesInTar", func(t *testing.T) {
t.Parallel()
result := &templatebuilder.ComposeResult{
MainTF: []byte("resource {}"),
ExtraFiles: map[string][]byte{
"cloud-init/config.yaml.tftpl": []byte("cloud config"),
"cloud-init/userdata.sh.tftpl": []byte("userdata"),
},
}
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Contains(t, files, "cloud-init/", "directory entry should be present for subdirectories")
require.Contains(t, files, "main.tf")
require.Contains(t, files, "cloud-init/config.yaml.tftpl")
require.Contains(t, files, "cloud-init/userdata.sh.tftpl")
require.Equal(t, "cloud config", files["cloud-init/config.yaml.tftpl"])
require.Equal(t, "userdata", files["cloud-init/userdata.sh.tftpl"])
})
t.Run("NestedStaticFileDirEntries", func(t *testing.T) {
t.Parallel()
result := &templatebuilder.ComposeResult{
MainTF: []byte("resource {}"),
ExtraFiles: map[string][]byte{
"a/b/c/deep.txt": []byte("deep"),
"top.txt": []byte("top"),
},
}
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Contains(t, files, "a/", "top-level parent dir entry")
require.Contains(t, files, "a/b/", "intermediate parent dir entry")
require.Contains(t, files, "a/b/c/", "leaf parent dir entry")
require.Contains(t, files, "a/b/c/deep.txt")
require.Contains(t, files, "top.txt")
// top.txt is at root, so no extra directory entry needed.
})
t.Run("AWSLinuxRoundTrip", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "aws-linux",
RegistryURL: "registry.coder.com",
})
require.NoError(t, err)
data, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
files := extractTar(t, data)
require.Contains(t, files, "main.tf")
require.Contains(t, files, "README.md")
require.Contains(t, files, "cloud-init/cloud-config.yaml.tftpl")
require.Contains(t, files, "cloud-init/userdata.sh.tftpl")
})
t.Run("ReproducibleArchive", func(t *testing.T) {
t.Parallel()
result := &templatebuilder.ComposeResult{
MainTF: []byte("resource {}"),
ModulesTF: []byte("module {}"),
}
data1, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
data2, err := templatebuilder.BundleTar(result)
require.NoError(t, err)
require.Equal(t, data1, data2, "identical inputs should produce identical archives")
})
}
// optionValuePattern matches a quoted `value = "..."` assignment. In the
// quickstart base such a quoted literal only appears inside the languages
// selector's option {} blocks: Docker labels assign `value = data....` and
// presets assign `languages = jsonencode(...)`, neither of which is a quoted
// `value = "..."`.
var optionValuePattern = regexp.MustCompile(`(?m)^\s*value\s*=\s*"([^"]+)"`)
// hasLanguageDispatchPattern matches the `if has_language <name>` call sites in
// the quickstart language-install script (not the has_language definition).
var hasLanguageDispatchPattern = regexp.MustCompile(`(?m)^\s*if has_language (\S+?);`)
// TestQuickstartLanguageSelectorMatchesInstallScript enforces that the
// quickstart "languages" selector options and the language-install script's
// has_language dispatch branches describe the same set of languages. They are
// two hand-maintained lists with nothing else binding them: if one gains or
// loses a language without the other, a selected language would silently
// install nothing (or a branch would be dead). This test fails on that drift.
func TestQuickstartLanguageSelectorMatchesInstallScript(t *testing.T) {
t.Parallel()
mainTF, err := templatebuilder.RenderBaseTemplate(
"quickstart", "main.tf.tmpl", templatebuilder.DefaultBaseRenderContext("quickstart"))
require.NoError(t, err)
var selectorValues []string
for _, m := range optionValuePattern.FindAllSubmatch(mainTF, -1) {
selectorValues = append(selectorValues, string(m[1]))
}
require.NotEmpty(t, selectorValues,
"expected the quickstart languages selector to declare options")
fsys, err := templatebuilder.BaseTemplateFS("quickstart")
require.NoError(t, err)
script, err := fs.ReadFile(fsys, "install-languages.sh.tftpl")
require.NoError(t, err)
var dispatchNames []string
for _, m := range hasLanguageDispatchPattern.FindAllSubmatch(script, -1) {
dispatchNames = append(dispatchNames, string(m[1]))
}
require.NotEmpty(t, dispatchNames,
"expected the install script to dispatch on has_language")
require.ElementsMatch(t, selectorValues, dispatchNames,
"quickstart languages selector options must match the install script's has_language branches")
}
// TestComposeBaseHonorsRegistryMirror verifies a base-embedded module source is
// rendered against ComposeRequest.RegistryURL, and falls back to the public
// default when it is unset. The quickstart base embeds the git-clone module.
func TestComposeBaseHonorsRegistryMirror(t *testing.T) {
t.Parallel()
t.Run("Mirror", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "quickstart",
RegistryURL: "mirror.internal.example",
})
require.NoError(t, err)
require.Contains(t, string(result.MainTF), "mirror.internal.example/coder/git-clone/coder")
require.NotContains(t, string(result.MainTF),
templatebuilder.DefaultRegistryBase+"/coder/git-clone/coder")
})
t.Run("DefaultsWhenUnset", func(t *testing.T) {
t.Parallel()
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "quickstart",
})
require.NoError(t, err)
require.Contains(t, string(result.MainTF),
templatebuilder.DefaultRegistryBase+"/coder/git-clone/coder")
})
t.Run("RejectsMalformed", func(t *testing.T) {
t.Parallel()
// The deployment value is validated at server start; this is the
// defense-in-depth reject for a direct caller that bypasses the boot check.
_, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "quickstart",
RegistryURL: "https://user:s3cr3t-token@mirror.example.com/coder",
})
require.ErrorContains(t, err, "bare host")
require.NotContains(t, err.Error(), "s3cr3t-token")
})
t.Run("StripsScheme", func(t *testing.T) {
t.Parallel()
// A value pasted with a scheme is normalized to a bare host in the source.
result, err := templatebuilder.Compose(templatebuilder.ComposeRequest{
BaseTemplateID: "quickstart",
RegistryURL: "https://mirror.internal.example/",
})
require.NoError(t, err)
require.Contains(t, string(result.MainTF), "mirror.internal.example/coder/git-clone/coder")
require.NotContains(t, string(result.MainTF), "https://mirror.internal.example")
})
}
// extractTar reads a tar archive and returns a map of filename to content.
func extractTar(t *testing.T, data []byte) map[string]string {
t.Helper()
tr := tar.NewReader(bytes.NewReader(data))
files := make(map[string]string)
for {
hdr, err := tr.Next()
if errors.Is(err, io.EOF) {
break
}
require.NoError(t, err)
body, err := io.ReadAll(tr)
require.NoError(t, err)
files[hdr.Name] = string(body)
}
return files
}