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.
775 lines
25 KiB
Go
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)
|
|
})
|
|
}
|
|
}
|