Files
Jeremy Ruppel e049627258 test(coderd/templatebuilder): fix ETXTBSY flake in TestQuickstartCppInstallGuard (#32403)
`TestQuickstartCppInstallGuard` wrote stub executables in parallel
subtests and then executed them through the quickstart install script. A
concurrent fork could inherit a stub's write fd, so the exec failed with
`Text file busy` (golang/go#22315). The stubs are now bash functions
prepended to the script, so the test does not write or execute any
files.

This PR also adds `TestBaseBundlesReferencedFiles`. It walks each base's
rendered `main.tf` HCL and checks that every `file()`/`templatefile()`
path is bundled in `BaseExtraFiles`. It replaces the hand-written
`AWSLinuxExtraFiles` and `AzureLinuxExtraFiles` subtests.

Fixes CLIENT-1102

<details>
<summary>Plan and decision log</summary>

### Fix CLIENT-1102: flake in TestQuickstartCppInstallGuard

#### Problem

`TestQuickstartCppInstallGuard` wrote stub executables in parallel
subtests, then executed the quickstart install script. A concurrent fork
could inherit a stub's write fd, so executing a stub failed with
`ETXTBSY` (golang/go#22315).

#### Decision log

1. Hold `syscall.ForkLock` while writing stubs. Rejected: it keeps the
file setup and protects only this process.
2. Replace the stub files with bash functions, so no file is written or
executed. Implemented.
3. Delete the test and only check that the files are referenced. Tried,
then reverted after review: the test is the only regression test for the
C/C++ install guard (#30374), and running scripts from Go tests is not
against repo policy.
4. Keep the reference check as a separate test. It covers a different
contract: every file that a base's `main.tf` passes to
`file()`/`templatefile()` must be bundled.

#### Change

- `TestQuickstartCppInstallGuard`: define the stubs as bash functions
prepended to the script. `PATH` is an empty temp dir, `sudo` echoes its
arguments, and the test checks stdout for `SUDO: apt-get install`.
- Add `TestBaseBundlesReferencedFiles`: one parallel subtest per base.
Each renders `main.tf` with `testRenderContext`, walks the parsed HCL
for `file()`/`templatefile()` calls, evaluates the path with
`path.module = "."`, and checks that it is a key of `BaseExtraFiles`,
which `Compose` passes through unchanged. A path that is not a literal
fails the test, and so does a base that bundles files without
referencing any of them. Calls in comments and heredocs are ignored.
- Remove the `AWSLinuxExtraFiles` and `AzureLinuxExtraFiles` subtests,
which only listed file names by hand and are now covered by
`TestBaseBundlesReferencedFiles`.

#### Verification

- With the guard set back to gcc only, `MissingCmake` and `OnlyGcc`
fail.
- `go test ./coderd/templatebuilder -run
'^TestQuickstartCppInstallGuard$' -count=500 -cpu=8` passes, as does the
whole package with `-count=20 -cpu=8`.
- Reference check mutations: a renamed quickstart reference, a removed
aws-linux file, and a misspelled DigitalOcean reference each fail the
subtest for that base with a short message. A path that is not a literal
fails. A call in a comment is ignored.
- `golangci-lint` (0 issues), `gofmt`, `git diff --check`.

</details>

---

_Generated with Coder Agents on behalf of @jeremyruppel._
2026-11-18 14:59:15 -05:00

813 lines
26 KiB
Go

package templatebuilder_test
import (
"archive/tar"
"bytes"
"errors"
"io"
"io/fs"
"os/exec"
"path"
"regexp"
"runtime"
"slices"
"strings"
"testing"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsyntax"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/zclconf/go-cty/cty"
"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("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("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
}
// TestQuickstartCppInstallGuard verifies the C/C++ branch of the quickstart
// install script installs the toolchain when only part of it is present. The
// base image ships gcc but not cmake, so guarding on gcc alone skipped the
// install and still reported success.
func TestQuickstartCppInstallGuard(t *testing.T) {
t.Parallel()
if runtime.GOOS == "windows" {
t.Skip("requires bash")
}
bash, err := exec.LookPath("bash")
require.NoError(t, err)
fsys, err := templatebuilder.BaseTemplateFS("quickstart")
require.NoError(t, err)
raw, err := fs.ReadFile(fsys, "install-languages.sh.tftpl")
require.NoError(t, err)
// Render the template the way Terraform's templatefile would for the
// two constructs the script uses.
script := strings.ReplaceAll(string(raw), "${LANGUAGES}", "cpp")
script = strings.ReplaceAll(script, "$$", "$")
// gcc is always present: the script echoes its version after installing.
tests := []struct {
name string
present []string
wantInstall bool
}{
{name: "AllPresent", present: []string{"gcc", "g++", "make", "cmake"}, wantInstall: false},
{name: "MissingCmake", present: []string{"gcc", "g++", "make"}, wantInstall: true},
{name: "OnlyGcc", present: []string{"gcc"}, wantInstall: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
// Stubs are shell functions rather than files on PATH: writing
// and executing files races with concurrent forks (ETXTBSY,
// golang/go#22315). PATH is an empty directory, so the host's
// toolchain can't influence the result.
var prelude strings.Builder
for _, tool := range tt.present {
prelude.WriteString(tool + "() { echo stub 1.0; }\n")
}
// sudo records its arguments and "installs" nothing.
prelude.WriteString("sudo() { echo \"SUDO: $*\"; }\n")
prelude.WriteString("head() { IFS= read -r l; printf '%s\\n' \"$l\"; }\n")
cmd := exec.Command(bash, "-c", prelude.String()+script)
cmd.Env = []string{"PATH=" + t.TempDir()}
out, err := cmd.CombinedOutput()
require.NoError(t, err, string(out))
installed := strings.Contains(string(out), "SUDO: apt-get install")
require.Equal(t, tt.wantInstall, installed, "output: %s", out)
})
}
}
// TestBaseBundlesReferencedFiles verifies every file a base's main.tf passes
// to file() or templatefile() is bundled with the base, so terraform plan can
// read it.
func TestBaseBundlesReferencedFiles(t *testing.T) {
t.Parallel()
ids := templatebuilder.BaseTemplateIDs()
slices.Sort(ids)
for _, id := range ids {
t.Run(id, func(t *testing.T) {
t.Parallel()
rendered, err := templatebuilder.RenderBaseTemplate(id, "main.tf.tmpl", testRenderContext(id))
require.NoError(t, err)
extraFiles := templatebuilder.BaseExtraFiles(id)
refs := fileReferences(t, rendered)
if len(extraFiles) > 0 {
require.NotEmpty(t, refs, "bundles files but no file() or templatefile() call was found")
}
for _, ref := range refs {
_, ok := extraFiles[ref]
assert.True(t, ok, "%q is referenced but not bundled", ref)
}
})
}
}
// fileReferences returns the paths that mainTF passes to file() and
// templatefile(), relative to the template root.
func fileReferences(t *testing.T, mainTF []byte) []string {
t.Helper()
file, diags := hclsyntax.ParseConfig(mainTF, "main.tf", hcl.InitialPos)
require.False(t, diags.HasErrors(), "%s", diags)
body, ok := file.Body.(*hclsyntax.Body)
require.True(t, ok)
// path.module is the template root, where ExtraFiles are written.
pathObj := cty.ObjectVal(map[string]cty.Value{
"module": cty.StringVal("."),
})
evalCtx := &hcl.EvalContext{
Variables: map[string]cty.Value{"path": pathObj},
}
var refs []string
diags = hclsyntax.VisitAll(body, func(node hclsyntax.Node) hcl.Diagnostics {
call, ok := node.(*hclsyntax.FunctionCallExpr)
if !ok || len(call.Args) == 0 {
return nil
}
if call.Name != "file" && call.Name != "templatefile" {
return nil
}
val, diags := call.Args[0].Value(evalCtx)
if diags.HasErrors() {
return diags
}
refs = append(refs, path.Clean(val.AsString()))
return nil
})
require.False(t, diags.HasErrors(), "file path must be a literal: %s", diags)
return refs
}