359 lines
8.9 KiB
Go
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")
|
|
}
|