23b82482f2
Move module identity to our own Forgejo instance. All import paths updated across 434 Go files, sub-module go.mod files, and go.work. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
604 lines
16 KiB
Go
604 lines
16 KiB
Go
package container
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"forge.lthn.ai/core/cli/pkg/io"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestListTemplates_Good(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
templates := tm.ListTemplates()
|
|
|
|
// Should have at least the builtin templates
|
|
assert.GreaterOrEqual(t, len(templates), 2)
|
|
|
|
// Find the core-dev template
|
|
var found bool
|
|
for _, tmpl := range templates {
|
|
if tmpl.Name == "core-dev" {
|
|
found = true
|
|
assert.NotEmpty(t, tmpl.Description)
|
|
assert.NotEmpty(t, tmpl.Path)
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found, "core-dev template should exist")
|
|
|
|
// Find the server-php template
|
|
found = false
|
|
for _, tmpl := range templates {
|
|
if tmpl.Name == "server-php" {
|
|
found = true
|
|
assert.NotEmpty(t, tmpl.Description)
|
|
assert.NotEmpty(t, tmpl.Path)
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found, "server-php template should exist")
|
|
}
|
|
|
|
func TestGetTemplate_Good_CoreDev(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
content, err := tm.GetTemplate("core-dev")
|
|
|
|
require.NoError(t, err)
|
|
assert.NotEmpty(t, content)
|
|
assert.Contains(t, content, "kernel:")
|
|
assert.Contains(t, content, "linuxkit/kernel")
|
|
assert.Contains(t, content, "${SSH_KEY}")
|
|
assert.Contains(t, content, "services:")
|
|
}
|
|
|
|
func TestGetTemplate_Good_ServerPhp(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
content, err := tm.GetTemplate("server-php")
|
|
|
|
require.NoError(t, err)
|
|
assert.NotEmpty(t, content)
|
|
assert.Contains(t, content, "kernel:")
|
|
assert.Contains(t, content, "frankenphp")
|
|
assert.Contains(t, content, "${SSH_KEY}")
|
|
assert.Contains(t, content, "${DOMAIN:-localhost}")
|
|
}
|
|
|
|
func TestGetTemplate_Bad_NotFound(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
_, err := tm.GetTemplate("nonexistent-template")
|
|
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "template not found")
|
|
}
|
|
|
|
func TestApplyVariables_Good_SimpleSubstitution(t *testing.T) {
|
|
content := "Hello ${NAME}, welcome to ${PLACE}!"
|
|
vars := map[string]string{
|
|
"NAME": "World",
|
|
"PLACE": "Core",
|
|
}
|
|
|
|
result, err := ApplyVariables(content, vars)
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Hello World, welcome to Core!", result)
|
|
}
|
|
|
|
func TestApplyVariables_Good_WithDefaults(t *testing.T) {
|
|
content := "Memory: ${MEMORY:-1024}MB, CPUs: ${CPUS:-2}"
|
|
vars := map[string]string{
|
|
"MEMORY": "2048",
|
|
// CPUS not provided, should use default
|
|
}
|
|
|
|
result, err := ApplyVariables(content, vars)
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Memory: 2048MB, CPUs: 2", result)
|
|
}
|
|
|
|
func TestApplyVariables_Good_AllDefaults(t *testing.T) {
|
|
content := "${HOST:-localhost}:${PORT:-8080}"
|
|
vars := map[string]string{} // No vars provided
|
|
|
|
result, err := ApplyVariables(content, vars)
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "localhost:8080", result)
|
|
}
|
|
|
|
func TestApplyVariables_Good_MixedSyntax(t *testing.T) {
|
|
content := `
|
|
hostname: ${HOSTNAME:-myhost}
|
|
ssh_key: ${SSH_KEY}
|
|
memory: ${MEMORY:-512}
|
|
`
|
|
vars := map[string]string{
|
|
"SSH_KEY": "ssh-rsa AAAA...",
|
|
"HOSTNAME": "custom-host",
|
|
}
|
|
|
|
result, err := ApplyVariables(content, vars)
|
|
|
|
require.NoError(t, err)
|
|
assert.Contains(t, result, "hostname: custom-host")
|
|
assert.Contains(t, result, "ssh_key: ssh-rsa AAAA...")
|
|
assert.Contains(t, result, "memory: 512")
|
|
}
|
|
|
|
func TestApplyVariables_Good_EmptyDefault(t *testing.T) {
|
|
content := "value: ${OPT:-}"
|
|
vars := map[string]string{}
|
|
|
|
result, err := ApplyVariables(content, vars)
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "value: ", result)
|
|
}
|
|
|
|
func TestApplyVariables_Bad_MissingRequired(t *testing.T) {
|
|
content := "SSH Key: ${SSH_KEY}"
|
|
vars := map[string]string{} // Missing required SSH_KEY
|
|
|
|
_, err := ApplyVariables(content, vars)
|
|
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "missing required variables")
|
|
assert.Contains(t, err.Error(), "SSH_KEY")
|
|
}
|
|
|
|
func TestApplyVariables_Bad_MultipleMissing(t *testing.T) {
|
|
content := "${VAR1} and ${VAR2} and ${VAR3}"
|
|
vars := map[string]string{
|
|
"VAR2": "provided",
|
|
}
|
|
|
|
_, err := ApplyVariables(content, vars)
|
|
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "missing required variables")
|
|
// Should mention both missing vars
|
|
errStr := err.Error()
|
|
assert.True(t, strings.Contains(errStr, "VAR1") || strings.Contains(errStr, "VAR3"))
|
|
}
|
|
|
|
func TestApplyTemplate_Good(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
vars := map[string]string{
|
|
"SSH_KEY": "ssh-rsa AAAA... user@host",
|
|
}
|
|
|
|
result, err := tm.ApplyTemplate("core-dev", vars)
|
|
|
|
require.NoError(t, err)
|
|
assert.NotEmpty(t, result)
|
|
assert.Contains(t, result, "ssh-rsa AAAA... user@host")
|
|
// Default values should be applied
|
|
assert.Contains(t, result, "core-dev") // HOSTNAME default
|
|
}
|
|
|
|
func TestApplyTemplate_Bad_TemplateNotFound(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
vars := map[string]string{
|
|
"SSH_KEY": "test",
|
|
}
|
|
|
|
_, err := tm.ApplyTemplate("nonexistent", vars)
|
|
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "template not found")
|
|
}
|
|
|
|
func TestApplyTemplate_Bad_MissingVariable(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
// server-php requires SSH_KEY
|
|
vars := map[string]string{} // Missing required SSH_KEY
|
|
|
|
_, err := tm.ApplyTemplate("server-php", vars)
|
|
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "missing required variables")
|
|
}
|
|
|
|
func TestExtractVariables_Good(t *testing.T) {
|
|
content := `
|
|
hostname: ${HOSTNAME:-myhost}
|
|
ssh_key: ${SSH_KEY}
|
|
memory: ${MEMORY:-1024}
|
|
cpus: ${CPUS:-2}
|
|
api_key: ${API_KEY}
|
|
`
|
|
required, optional := ExtractVariables(content)
|
|
|
|
// Required variables (no default)
|
|
assert.Contains(t, required, "SSH_KEY")
|
|
assert.Contains(t, required, "API_KEY")
|
|
assert.Len(t, required, 2)
|
|
|
|
// Optional variables (with defaults)
|
|
assert.Equal(t, "myhost", optional["HOSTNAME"])
|
|
assert.Equal(t, "1024", optional["MEMORY"])
|
|
assert.Equal(t, "2", optional["CPUS"])
|
|
assert.Len(t, optional, 3)
|
|
}
|
|
|
|
func TestExtractVariables_Good_NoVariables(t *testing.T) {
|
|
content := "This has no variables at all"
|
|
|
|
required, optional := ExtractVariables(content)
|
|
|
|
assert.Empty(t, required)
|
|
assert.Empty(t, optional)
|
|
}
|
|
|
|
func TestExtractVariables_Good_OnlyDefaults(t *testing.T) {
|
|
content := "${A:-default1} ${B:-default2}"
|
|
|
|
required, optional := ExtractVariables(content)
|
|
|
|
assert.Empty(t, required)
|
|
assert.Len(t, optional, 2)
|
|
assert.Equal(t, "default1", optional["A"])
|
|
assert.Equal(t, "default2", optional["B"])
|
|
}
|
|
|
|
func TestScanUserTemplates_Good(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
// Create a temporary directory with template files
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create a valid template file
|
|
templateContent := `# My Custom Template
|
|
# A custom template for testing
|
|
kernel:
|
|
image: linuxkit/kernel:6.6
|
|
`
|
|
err := os.WriteFile(filepath.Join(tmpDir, "custom.yml"), []byte(templateContent), 0644)
|
|
require.NoError(t, err)
|
|
|
|
// Create a non-template file (should be ignored)
|
|
err = os.WriteFile(filepath.Join(tmpDir, "readme.txt"), []byte("Not a template"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
assert.Len(t, templates, 1)
|
|
assert.Equal(t, "custom", templates[0].Name)
|
|
assert.Equal(t, "My Custom Template", templates[0].Description)
|
|
}
|
|
|
|
func TestScanUserTemplates_Good_MultipleTemplates(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create multiple template files
|
|
err := os.WriteFile(filepath.Join(tmpDir, "web.yml"), []byte("# Web Server\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
err = os.WriteFile(filepath.Join(tmpDir, "db.yaml"), []byte("# Database Server\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
assert.Len(t, templates, 2)
|
|
|
|
// Check names are extracted correctly
|
|
names := make(map[string]bool)
|
|
for _, tmpl := range templates {
|
|
names[tmpl.Name] = true
|
|
}
|
|
assert.True(t, names["web"])
|
|
assert.True(t, names["db"])
|
|
}
|
|
|
|
func TestScanUserTemplates_Good_EmptyDirectory(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
assert.Empty(t, templates)
|
|
}
|
|
|
|
func TestScanUserTemplates_Bad_NonexistentDirectory(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
templates := tm.scanUserTemplates("/nonexistent/path/to/templates")
|
|
|
|
assert.Empty(t, templates)
|
|
}
|
|
|
|
func TestExtractTemplateDescription_Good(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
path := filepath.Join(tmpDir, "test.yml")
|
|
|
|
content := `# My Template Description
|
|
# More details here
|
|
kernel:
|
|
image: test
|
|
`
|
|
err := os.WriteFile(path, []byte(content), 0644)
|
|
require.NoError(t, err)
|
|
|
|
desc := tm.extractTemplateDescription(path)
|
|
|
|
assert.Equal(t, "My Template Description", desc)
|
|
}
|
|
|
|
func TestExtractTemplateDescription_Good_NoComments(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
path := filepath.Join(tmpDir, "test.yml")
|
|
|
|
content := `kernel:
|
|
image: test
|
|
`
|
|
err := os.WriteFile(path, []byte(content), 0644)
|
|
require.NoError(t, err)
|
|
|
|
desc := tm.extractTemplateDescription(path)
|
|
|
|
assert.Empty(t, desc)
|
|
}
|
|
|
|
func TestExtractTemplateDescription_Bad_FileNotFound(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
desc := tm.extractTemplateDescription("/nonexistent/file.yml")
|
|
|
|
assert.Empty(t, desc)
|
|
}
|
|
|
|
func TestVariablePatternEdgeCases_Good(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
content string
|
|
vars map[string]string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "underscore in name",
|
|
content: "${MY_VAR:-default}",
|
|
vars: map[string]string{"MY_VAR": "value"},
|
|
expected: "value",
|
|
},
|
|
{
|
|
name: "numbers in name",
|
|
content: "${VAR123:-default}",
|
|
vars: map[string]string{},
|
|
expected: "default",
|
|
},
|
|
{
|
|
name: "default with special chars",
|
|
content: "${URL:-http://localhost:8080}",
|
|
vars: map[string]string{},
|
|
expected: "http://localhost:8080",
|
|
},
|
|
{
|
|
name: "default with path",
|
|
content: "${PATH:-/usr/local/bin}",
|
|
vars: map[string]string{},
|
|
expected: "/usr/local/bin",
|
|
},
|
|
{
|
|
name: "adjacent variables",
|
|
content: "${A:-a}${B:-b}${C:-c}",
|
|
vars: map[string]string{"B": "X"},
|
|
expected: "aXc",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := ApplyVariables(tt.content, tt.vars)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.expected, result)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestListTemplates_Good_WithUserTemplates(t *testing.T) {
|
|
// Create a workspace directory with user templates
|
|
tmpDir := t.TempDir()
|
|
coreDir := filepath.Join(tmpDir, ".core", "linuxkit")
|
|
err := os.MkdirAll(coreDir, 0755)
|
|
require.NoError(t, err)
|
|
|
|
// Create a user template
|
|
templateContent := `# Custom user template
|
|
kernel:
|
|
image: linuxkit/kernel:6.6
|
|
`
|
|
err = os.WriteFile(filepath.Join(coreDir, "user-custom.yml"), []byte(templateContent), 0644)
|
|
require.NoError(t, err)
|
|
|
|
tm := NewTemplateManager(io.Local).WithWorkingDir(tmpDir)
|
|
templates := tm.ListTemplates()
|
|
|
|
// Should have at least the builtin templates plus the user template
|
|
assert.GreaterOrEqual(t, len(templates), 3)
|
|
|
|
// Check that user template is included
|
|
found := false
|
|
for _, tmpl := range templates {
|
|
if tmpl.Name == "user-custom" {
|
|
found = true
|
|
assert.Equal(t, "Custom user template", tmpl.Description)
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found, "user-custom template should exist")
|
|
}
|
|
|
|
func TestGetTemplate_Good_UserTemplate(t *testing.T) {
|
|
// Create a workspace directory with user templates
|
|
tmpDir := t.TempDir()
|
|
coreDir := filepath.Join(tmpDir, ".core", "linuxkit")
|
|
err := os.MkdirAll(coreDir, 0755)
|
|
require.NoError(t, err)
|
|
|
|
// Create a user template
|
|
templateContent := `# My user template
|
|
kernel:
|
|
image: linuxkit/kernel:6.6
|
|
services:
|
|
- name: test
|
|
`
|
|
err = os.WriteFile(filepath.Join(coreDir, "my-user-template.yml"), []byte(templateContent), 0644)
|
|
require.NoError(t, err)
|
|
|
|
tm := NewTemplateManager(io.Local).WithWorkingDir(tmpDir)
|
|
content, err := tm.GetTemplate("my-user-template")
|
|
|
|
require.NoError(t, err)
|
|
assert.Contains(t, content, "kernel:")
|
|
assert.Contains(t, content, "My user template")
|
|
}
|
|
|
|
func TestGetTemplate_Good_UserTemplate_YamlExtension(t *testing.T) {
|
|
// Create a workspace directory with user templates
|
|
tmpDir := t.TempDir()
|
|
coreDir := filepath.Join(tmpDir, ".core", "linuxkit")
|
|
err := os.MkdirAll(coreDir, 0755)
|
|
require.NoError(t, err)
|
|
|
|
// Create a user template with .yaml extension
|
|
templateContent := `# My yaml template
|
|
kernel:
|
|
image: linuxkit/kernel:6.6
|
|
`
|
|
err = os.WriteFile(filepath.Join(coreDir, "my-yaml-template.yaml"), []byte(templateContent), 0644)
|
|
require.NoError(t, err)
|
|
|
|
tm := NewTemplateManager(io.Local).WithWorkingDir(tmpDir)
|
|
content, err := tm.GetTemplate("my-yaml-template")
|
|
|
|
require.NoError(t, err)
|
|
assert.Contains(t, content, "kernel:")
|
|
assert.Contains(t, content, "My yaml template")
|
|
}
|
|
|
|
func TestScanUserTemplates_Good_SkipsBuiltinNames(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create a template with a builtin name (should be skipped)
|
|
err := os.WriteFile(filepath.Join(tmpDir, "core-dev.yml"), []byte("# Duplicate\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
// Create a unique template
|
|
err = os.WriteFile(filepath.Join(tmpDir, "unique.yml"), []byte("# Unique\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
// Should only have the unique template, not the builtin name
|
|
assert.Len(t, templates, 1)
|
|
assert.Equal(t, "unique", templates[0].Name)
|
|
}
|
|
|
|
func TestScanUserTemplates_Good_SkipsDirectories(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create a subdirectory (should be skipped)
|
|
err := os.MkdirAll(filepath.Join(tmpDir, "subdir"), 0755)
|
|
require.NoError(t, err)
|
|
|
|
// Create a valid template
|
|
err = os.WriteFile(filepath.Join(tmpDir, "valid.yml"), []byte("# Valid\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
assert.Len(t, templates, 1)
|
|
assert.Equal(t, "valid", templates[0].Name)
|
|
}
|
|
|
|
func TestScanUserTemplates_Good_YamlExtension(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create templates with both extensions
|
|
err := os.WriteFile(filepath.Join(tmpDir, "template1.yml"), []byte("# Template 1\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
err = os.WriteFile(filepath.Join(tmpDir, "template2.yaml"), []byte("# Template 2\nkernel:"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
assert.Len(t, templates, 2)
|
|
|
|
names := make(map[string]bool)
|
|
for _, tmpl := range templates {
|
|
names[tmpl.Name] = true
|
|
}
|
|
assert.True(t, names["template1"])
|
|
assert.True(t, names["template2"])
|
|
}
|
|
|
|
func TestExtractTemplateDescription_Good_EmptyComment(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
path := filepath.Join(tmpDir, "test.yml")
|
|
|
|
// First comment is empty, second has content
|
|
content := `#
|
|
# Actual description here
|
|
kernel:
|
|
image: test
|
|
`
|
|
err := os.WriteFile(path, []byte(content), 0644)
|
|
require.NoError(t, err)
|
|
|
|
desc := tm.extractTemplateDescription(path)
|
|
|
|
assert.Equal(t, "Actual description here", desc)
|
|
}
|
|
|
|
func TestExtractTemplateDescription_Good_MultipleEmptyComments(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
path := filepath.Join(tmpDir, "test.yml")
|
|
|
|
// Multiple empty comments before actual content
|
|
content := `#
|
|
#
|
|
#
|
|
# Real description
|
|
kernel:
|
|
image: test
|
|
`
|
|
err := os.WriteFile(path, []byte(content), 0644)
|
|
require.NoError(t, err)
|
|
|
|
desc := tm.extractTemplateDescription(path)
|
|
|
|
assert.Equal(t, "Real description", desc)
|
|
}
|
|
|
|
func TestGetUserTemplatesDir_Good_NoDirectory(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local).WithWorkingDir("/tmp/nonexistent-wd").WithHomeDir("/tmp/nonexistent-home")
|
|
dir := tm.getUserTemplatesDir()
|
|
|
|
assert.Empty(t, dir)
|
|
}
|
|
|
|
func TestScanUserTemplates_Good_DefaultDescription(t *testing.T) {
|
|
tm := NewTemplateManager(io.Local)
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create a template without comments
|
|
content := `kernel:
|
|
image: test
|
|
`
|
|
err := os.WriteFile(filepath.Join(tmpDir, "nocomment.yml"), []byte(content), 0644)
|
|
require.NoError(t, err)
|
|
|
|
templates := tm.scanUserTemplates(tmpDir)
|
|
|
|
assert.Len(t, templates, 1)
|
|
assert.Equal(t, "User-defined template", templates[0].Description)
|
|
}
|