## 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>
703 lines
23 KiB
Go
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
|
|
}
|