Files
coder/coderd/templatebuilder/compose_test.go
T
Nick Vigilante 6afd1515e0 fix(coderd/templatebuilder): guard quickstart C/C++ install on every tool it installs (#30374)
The Quickstart base's C/C++ branch guarded on `command -v gcc`, but
installs `gcc g++ make cmake`. `codercom/enterprise-base:ubuntu` ships
gcc but not cmake, so cmake was never installed while the script
reported success. The guard now checks every tool the install provides
(`gcc`, `g++`, `make`, `cmake`).

Adds `TestQuickstartCppInstallGuard`, which runs the rendered C/C++
branch against stubbed tools and asserts the install runs when any of
them is missing. It fails without the fix.

Fixes DOCS-736. The matching example template change is in the DOCS-613
PR.

Generated by Coder Agents on behalf of @nickvigilante.
2026-10-14 12:35:48 -04:00

775 lines
25 KiB
Go

package templatebuilder_test
import (
"archive/tar"
"bytes"
"errors"
"io"
"io/fs"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"strings"
"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
}
// 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)
head, err := exec.LookPath("head")
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()
// PATH holds only stubs, so the host's real toolchain can't
// influence the result.
binDir := t.TempDir()
writeExecutable := func(name, content string) {
path := filepath.Join(binDir, name)
require.NoError(t, os.WriteFile(path, []byte(content), 0o600))
require.NoError(t, os.Chmod(path, 0o700))
}
require.NoError(t, os.Symlink(head, filepath.Join(binDir, "head")))
stub := "#!" + bash + "\necho stub 1.0\n"
for _, tool := range tt.present {
writeExecutable(tool, stub)
}
// The sudo stub records its arguments and "installs" nothing.
logPath := filepath.Join(t.TempDir(), "sudo.log")
sudo := "#!" + bash + "\necho \"$@\" >> " + logPath + "\n"
writeExecutable("sudo", sudo)
cmd := exec.Command(bash, "-c", script)
cmd.Env = []string{"PATH=" + binDir, "HOME=" + t.TempDir()}
out, err := cmd.CombinedOutput()
require.NoError(t, err, string(out))
logged, _ := os.ReadFile(logPath)
installed := strings.Contains(string(logged), "install")
require.Equal(t, tt.wantInstall, installed, "output: %s", out)
})
}
}