Files
coder/coderd/templatebuilder/bases_internal_test.go
T

359 lines
8.9 KiB
Go

package templatebuilder
import (
"testing"
"testing/fstest"
"github.com/stretchr/testify/require"
)
func TestParseBasesFromFS(t *testing.T) {
t.Parallel()
t.Run("ValidManifest", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/docker/base.json": &fstest.MapFile{
Data: []byte(`{
"id": "docker",
"display_name": "Docker",
"os": "linux",
"default_context": {
"container_image": "codercom/enterprise-base:ubuntu"
}
}`),
},
"bases/docker/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`image = "{{ .ContainerImage }}"`),
},
"bases/docker/README.md": &fstest.MapFile{
Data: []byte("# Docker\n"),
},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
require.Len(t, bases, 1)
b := bases["docker"]
require.NotNil(t, b)
require.Equal(t, "docker", b.Manifest.ID)
require.Equal(t, "Docker", b.Manifest.DisplayName)
require.Equal(t, "linux", b.Manifest.OS)
require.Equal(t, "codercom/enterprise-base:ubuntu", b.Manifest.DefaultContext.ContainerImage)
require.Contains(t, b.Templates, "main.tf.tmpl")
})
t.Run("MultipleBases", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/alpha/base.json": &fstest.MapFile{
Data: []byte(`{"id": "alpha", "os": "linux"}`),
},
"bases/alpha/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`resource "alpha" {}`),
},
"bases/alpha/README.md": &fstest.MapFile{
Data: []byte("# Alpha\n"),
},
"bases/beta/base.json": &fstest.MapFile{
Data: []byte(`{"id": "beta", "os": "linux"}`),
},
"bases/beta/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`resource "beta" {}`),
},
"bases/beta/README.md": &fstest.MapFile{
Data: []byte("# Beta\n"),
},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
require.Len(t, bases, 2)
require.NotNil(t, bases["alpha"])
require.NotNil(t, bases["beta"])
})
t.Run("EmptyCatalog", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/.keep": &fstest.MapFile{Data: []byte{}},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
require.Empty(t, bases)
})
t.Run("PreParsesTemplates", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/mybase/base.json": &fstest.MapFile{
Data: []byte(`{"id": "mybase", "os": "linux"}`),
},
"bases/mybase/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`image = "{{ .ContainerImage }}"`),
},
// .tftpl files are Terraform templatefile() inputs, not Go templates.
"bases/mybase/cloud-init/config.yaml.tftpl": &fstest.MapFile{
Data: []byte(`${some_terraform_var}`),
},
"bases/mybase/README.md": &fstest.MapFile{
Data: []byte("# My Base\n"),
},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
b := bases["mybase"]
require.NotNil(t, b)
require.Contains(t, b.Templates, "main.tf.tmpl")
// .tftpl files should not be pre-parsed as Go templates.
require.NotContains(t, b.Templates, "cloud-init/config.yaml.tftpl")
})
t.Run("RejectsMissingReadme", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux"}`),
},
"bases/bad/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`resource {}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "read README.md for base")
})
t.Run("RejectsDirWithoutManifest", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/nobase/readme.txt": &fstest.MapFile{Data: []byte("hi")},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "read nobase/base.json")
})
t.Run("RejectsEmptyID", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "", "os": "linux"}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "empty id")
})
t.Run("RejectsDuplicateID", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/a/base.json": &fstest.MapFile{
Data: []byte(`{"id": "dupe", "os": "linux"}`),
},
"bases/a/README.md": &fstest.MapFile{
Data: []byte("# A\n"),
},
"bases/b/base.json": &fstest.MapFile{
Data: []byte(`{"id": "dupe", "os": "linux"}`),
},
"bases/b/README.md": &fstest.MapFile{
Data: []byte("# B\n"),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "duplicate base id")
})
t.Run("RejectsUnknownOS", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "beos"}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, `unknown os "beos"`)
})
t.Run("RejectsUnknownField", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux", "dispaly_name": "typo"}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "decode")
})
t.Run("RejectsInvalidJSON", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{not json`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "decode")
})
t.Run("RejectsInvalidTemplate", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux"}`),
},
"bases/bad/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`{{ .Broken`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "parse templates")
})
t.Run("AllowsEmptyOS", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/nospec/base.json": &fstest.MapFile{
Data: []byte(`{"id": "nospec"}`),
},
"bases/nospec/README.md": &fstest.MapFile{
Data: []byte("# No Spec\n"),
},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
require.Equal(t, "", bases["nospec"].Manifest.OS)
})
t.Run("AcceptsWindowsOS", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/winbox/base.json": &fstest.MapFile{
Data: []byte(`{"id": "winbox", "os": "windows"}`),
},
"bases/winbox/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`resource "coder_agent" "main" {}`),
},
"bases/winbox/README.md": &fstest.MapFile{
Data: []byte("# Windows\n"),
},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
require.Equal(t, "windows", bases["winbox"].Manifest.OS)
require.Equal(t, BaseOSWindows, validBaseOS[bases["winbox"].Manifest.OS])
})
t.Run("ParsesAgents", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/multi/base.json": &fstest.MapFile{
Data: []byte(`{"id": "multi", "os": "linux", "agents": [{"name": "main"}, {"name": "gpu", "default": true}]}`),
},
"bases/multi/main.tf.tmpl": &fstest.MapFile{
Data: []byte(`resource "coder_agent" "main" {}
resource "coder_agent" "gpu" {}`),
},
"bases/multi/README.md": &fstest.MapFile{
Data: []byte("# Multi\n"),
},
}
bases, err := parseBasesFromFS(fsys)
require.NoError(t, err)
agents := bases["multi"].Manifest.Agents
require.Equal(t, []BaseAgent{{Name: "main"}, {Name: "gpu", Default: true}}, agents)
})
t.Run("RejectsEmptyAgentName", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux", "agents": [{"name": ""}]}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "empty name")
})
t.Run("RejectsDuplicateAgentName", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux", "agents": [{"name": "main"}, {"name": "main"}]}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "duplicate agent name")
})
t.Run("RejectsMultipleDefaultAgents", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux", "agents": [{"name": "a", "default": true}, {"name": "b", "default": true}]}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "exactly one required")
})
t.Run("RejectsMultiAgentWithoutDefault", func(t *testing.T) {
t.Parallel()
fsys := fstest.MapFS{
"bases/bad/base.json": &fstest.MapFile{
Data: []byte(`{"id": "bad", "os": "linux", "agents": [{"name": "a"}, {"name": "b"}]}`),
},
}
_, err := parseBasesFromFS(fsys)
require.ErrorContains(t, err, "exactly one required")
})
}
func TestDefaultAgentName(t *testing.T) {
t.Parallel()
require.Equal(t, "", defaultAgentName(nil))
require.Equal(t, "main", defaultAgentName([]BaseAgent{{Name: "main"}, {Name: "gpu"}}),
"first agent is the default when none is marked")
require.Equal(t, "gpu", defaultAgentName([]BaseAgent{{Name: "main"}, {Name: "gpu", Default: true}}),
"the marked agent is the default")
}