warkanum
95143dd998
Add runtime: script (shell file, default /bin/bash, optional stop_script) and runtime: exec (executable with args, optional stop_executable). Both support service_type simple|oneshot and working_dir.
521 lines
13 KiB
Go
521 lines
13 KiB
Go
package systemd
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/warkanum/unitdore/config"
|
|
)
|
|
|
|
func TestServiceName(t *testing.T) {
|
|
u := config.Unit{Name: "nginx"}
|
|
|
|
tests := []struct {
|
|
prefix, suffix, want string
|
|
}{
|
|
{"", "", "unitdore-nginx.service"},
|
|
{"prod-", "", "unitdore-prod-nginx.service"},
|
|
{"", "-web", "unitdore-nginx-web.service"},
|
|
{"prod-", "-web", "unitdore-prod-nginx-web.service"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
got := ServiceName(u, tt.prefix, tt.suffix)
|
|
if got != tt.want {
|
|
t.Errorf("ServiceName(%q, %q) = %q, want %q", tt.prefix, tt.suffix, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerate_SystemUnit(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "nginx",
|
|
Runtime: "podman",
|
|
Order: 1,
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
checks := []string{
|
|
"[Unit]",
|
|
"[Service]",
|
|
"[Install]",
|
|
"unitdore-nginx.service",
|
|
"Description=Unitdore: nginx (podman)",
|
|
"After=network.target",
|
|
"WantedBy=multi-user.target",
|
|
"ExecStart=/usr/bin/podman start -a nginx",
|
|
"ExecStop=-/usr/bin/podman stop nginx",
|
|
"Generated by unitdore",
|
|
}
|
|
|
|
for _, check := range checks {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
|
|
if strings.Contains(content, "User=") {
|
|
t.Errorf("Generate() system unit should not contain User= directive:\n%s", content)
|
|
}
|
|
if strings.Contains(content, "Requires=") {
|
|
t.Errorf("Generate() podman system unit should not contain Requires= (podman is daemonless):\n%s", content)
|
|
}
|
|
if strings.Contains(content, "Restart=") {
|
|
t.Errorf("Generate() restart should be disabled by default:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_UserUnit(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "myapp",
|
|
Runtime: "docker",
|
|
User: "hein",
|
|
Order: 2,
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
checks := []string{
|
|
"After=default.target",
|
|
"WantedBy=default.target",
|
|
"ExecStart=/usr/bin/docker start -a myapp",
|
|
"ExecStop=-/usr/bin/docker stop myapp",
|
|
}
|
|
|
|
for _, check := range checks {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() user unit missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
|
|
if strings.Contains(content, "WantedBy=multi-user.target") {
|
|
t.Error("Generate() user unit should not contain multi-user.target")
|
|
}
|
|
}
|
|
|
|
func TestGenerate_WithRestart(t *testing.T) {
|
|
t.Run("restart with retries", func(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "nginx",
|
|
Runtime: "podman",
|
|
Enabled: true,
|
|
Restart: true,
|
|
RestartSec: 5,
|
|
RestartRetries: 3,
|
|
}
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
for _, want := range []string{"Restart=on-failure", "RestartSec=5", "StartLimitBurst=3"} {
|
|
if !strings.Contains(content, want) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", want, content)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("restart without retries", func(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "nginx",
|
|
Runtime: "podman",
|
|
Enabled: true,
|
|
Restart: true,
|
|
RestartSec: 10,
|
|
}
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
if !strings.Contains(content, "Restart=on-failure") {
|
|
t.Errorf("Generate() missing Restart=on-failure:\n%s", content)
|
|
}
|
|
if !strings.Contains(content, "RestartSec=10") {
|
|
t.Errorf("Generate() missing RestartSec=10:\n%s", content)
|
|
}
|
|
if strings.Contains(content, "StartLimitBurst") {
|
|
t.Errorf("Generate() should not contain StartLimitBurst when retries=0:\n%s", content)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestGenerate_CustomCommand(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "custom",
|
|
Runtime: "podman",
|
|
Command: "/usr/local/bin/mystart.sh",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(content, "ExecStart=/usr/local/bin/mystart.sh") {
|
|
t.Errorf("Generate() should use custom command, got:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_DockerRuntime(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "redis",
|
|
Runtime: "docker",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
checks := []string{
|
|
"ExecStart=/usr/bin/docker start -a redis",
|
|
"ExecStop=-/usr/bin/docker stop redis",
|
|
"After=network.target docker.service",
|
|
"Requires=docker.service",
|
|
}
|
|
for _, check := range checks {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() docker runtime missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerate_UnknownRuntime(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "weird",
|
|
Runtime: "containerd",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() should not error on unknown runtime: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(content, "/usr/bin/containerd start weird") {
|
|
t.Errorf("Generate() should fall back to /usr/bin/<runtime> for unknown runtimes:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_WithPrefixSuffix(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "nginx",
|
|
Runtime: "podman",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "prod-", "-web")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(content, "unitdore-prod-nginx-web.service") {
|
|
t.Errorf("Generate() prefix+suffix not reflected in service name:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestBuildExecCommands(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
unit config.Unit
|
|
wantStart string
|
|
wantStop string
|
|
}{
|
|
{
|
|
name: "podman",
|
|
unit: config.Unit{Name: "app", Runtime: "podman"},
|
|
wantStart: "/usr/bin/podman start -a app",
|
|
wantStop: "/usr/bin/podman stop app",
|
|
},
|
|
{
|
|
name: "docker",
|
|
unit: config.Unit{Name: "app", Runtime: "docker"},
|
|
wantStart: "/usr/bin/docker start -a app",
|
|
wantStop: "/usr/bin/docker stop app",
|
|
},
|
|
{
|
|
name: "custom command",
|
|
unit: config.Unit{Name: "app", Runtime: "podman", Command: "/bin/custom"},
|
|
wantStart: "/bin/custom",
|
|
wantStop: "",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
start, stop := buildExecCommands(tt.unit)
|
|
if start != tt.wantStart {
|
|
t.Errorf("start = %q, want %q", start, tt.wantStart)
|
|
}
|
|
if stop != tt.wantStop {
|
|
t.Errorf("stop = %q, want %q", stop, tt.wantStop)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// newComposeStack creates a stack unit whose compose binary, working dir and
|
|
// compose file exist on disk (compose mode).
|
|
func newComposeStack(t *testing.T) config.Unit {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
bin := filepath.Join(dir, "podman-compose")
|
|
if err := os.WriteFile(bin, []byte("#!/bin/sh\n"), 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "compose.yaml"), []byte("services: {}\n"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return config.Unit{
|
|
Name: "shop",
|
|
Runtime: "podman",
|
|
Kind: config.KindStack,
|
|
Project: "shop",
|
|
WorkingDir: dir,
|
|
ComposeFiles: []string{"compose.yaml"},
|
|
ComposeBin: bin,
|
|
Enabled: true,
|
|
}
|
|
}
|
|
|
|
func TestStackMode(t *testing.T) {
|
|
u := newComposeStack(t)
|
|
if StackMode(u) != StackModeCompose {
|
|
t.Errorf("StackMode() = %q, want compose", StackMode(u))
|
|
}
|
|
|
|
missingFile := u
|
|
missingFile.ComposeFiles = []string{"gone.yaml"}
|
|
if StackMode(missingFile) != StackModePod {
|
|
t.Error("missing compose file should fall back to pod mode")
|
|
}
|
|
|
|
missingBin := u
|
|
missingBin.ComposeBin = ""
|
|
if StackMode(missingBin) != StackModePod {
|
|
t.Error("missing compose binary should fall back to pod mode")
|
|
}
|
|
|
|
missingDir := u
|
|
missingDir.WorkingDir = "/nonexistent/unitdore-test"
|
|
if StackMode(missingDir) != StackModePod {
|
|
t.Error("missing working dir should fall back to pod mode")
|
|
}
|
|
}
|
|
|
|
func TestGenerate_StackCompose(t *testing.T) {
|
|
u := newComposeStack(t)
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
base := u.ComposeBin + " -p shop -f compose.yaml"
|
|
for _, want := range []string{
|
|
"Description=Unitdore: shop (podman-compose stack)",
|
|
"Type=simple",
|
|
"WorkingDirectory=" + u.WorkingDir,
|
|
"ExecStart=" + base + " up",
|
|
"ExecStop=-" + base + " stop",
|
|
"WantedBy=multi-user.target",
|
|
} {
|
|
if !strings.Contains(content, want) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", want, content)
|
|
}
|
|
}
|
|
if strings.Contains(content, "RemainAfterExit") || strings.Contains(content, "Requires=") {
|
|
t.Errorf("compose stack unit has unexpected directives:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_StackPodFallback(t *testing.T) {
|
|
u := newComposeStack(t)
|
|
u.ComposeBin = ""
|
|
u.User = "hein"
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
for _, want := range []string{
|
|
"Description=Unitdore: shop (podman pod)",
|
|
"Type=oneshot",
|
|
"RemainAfterExit=yes",
|
|
"ExecStart=/usr/bin/podman pod start pod_shop",
|
|
"ExecStop=-/usr/bin/podman pod stop pod_shop",
|
|
"WantedBy=default.target",
|
|
} {
|
|
if !strings.Contains(content, want) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", want, content)
|
|
}
|
|
}
|
|
if strings.Contains(content, "WorkingDirectory=") {
|
|
t.Errorf("pod fallback should not set WorkingDirectory:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_StackCustomCommand(t *testing.T) {
|
|
u := newComposeStack(t)
|
|
u.Command = "/usr/local/bin/stack.sh"
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
if !strings.Contains(content, "ExecStart=/usr/local/bin/stack.sh") {
|
|
t.Errorf("custom command should override stack commands:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestBuildComposeCommands_Quoting(t *testing.T) {
|
|
u := config.Unit{
|
|
Project: "shop",
|
|
ComposeBin: "/usr/bin/podman-compose",
|
|
ComposeFiles: []string{"compose.yaml", "my override.yaml"},
|
|
}
|
|
start, stop := buildComposeCommands(u)
|
|
wantBase := `/usr/bin/podman-compose -p shop -f compose.yaml -f "my override.yaml"`
|
|
if start != wantBase+" up" {
|
|
t.Errorf("start = %q", start)
|
|
}
|
|
if stop != wantBase+" stop" {
|
|
t.Errorf("stop = %q", stop)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_Script(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "backup",
|
|
Runtime: config.RuntimeScript,
|
|
Script: "/opt/scripts/backup.sh",
|
|
StopScript: "/opt/scripts/backup-stop.sh",
|
|
WorkingDir: "/opt/scripts",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
checks := []string{
|
|
"Description=Unitdore: backup (bash script)",
|
|
"Type=simple",
|
|
"WorkingDirectory=/opt/scripts",
|
|
"ExecStart=/bin/bash /opt/scripts/backup.sh",
|
|
"ExecStop=-/bin/bash /opt/scripts/backup-stop.sh",
|
|
}
|
|
for _, check := range checks {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() script missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
if strings.Contains(content, "Requires=") {
|
|
t.Errorf("Generate() script unit should not contain Requires=:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_ScriptOneshotUserQuoted(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "setup",
|
|
Runtime: config.RuntimeScript,
|
|
User: "alice",
|
|
Script: "/home/alice/my scripts/setup.sh",
|
|
ServiceType: "oneshot",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
|
|
checks := []string{
|
|
"Type=oneshot",
|
|
"RemainAfterExit=yes",
|
|
`ExecStart=/bin/bash "/home/alice/my scripts/setup.sh"`,
|
|
"WantedBy=default.target",
|
|
}
|
|
for _, check := range checks {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
if strings.Contains(content, "ExecStop=-") {
|
|
t.Errorf("Generate() should have no stop command without stop_script:\n%s", content)
|
|
}
|
|
}
|
|
|
|
func TestGenerate_ScriptMissingPath(t *testing.T) {
|
|
u := config.Unit{Name: "bad", Runtime: config.RuntimeScript, Enabled: true}
|
|
if _, err := Generate(u, "", ""); err == nil {
|
|
t.Error("Generate() should error when script path is empty")
|
|
}
|
|
}
|
|
|
|
func TestGenerate_ScriptCustomShell(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "fishy",
|
|
Runtime: config.RuntimeScript,
|
|
Shell: "/usr/bin/zsh",
|
|
Script: "/opt/run.zsh",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
for _, check := range []string{"Description=Unitdore: fishy (zsh script)", "ExecStart=/usr/bin/zsh /opt/run.zsh"} {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerate_Executable(t *testing.T) {
|
|
u := config.Unit{
|
|
Name: "agent",
|
|
Runtime: config.RuntimeExec,
|
|
Executable: "/opt/agent/bin/agent",
|
|
Args: []string{"--config", "/etc/my agent.toml"},
|
|
StopExecutable: "/opt/agent/bin/agent-stop",
|
|
WorkingDir: "/opt/agent",
|
|
ServiceType: "oneshot",
|
|
Enabled: true,
|
|
}
|
|
|
|
content, err := Generate(u, "", "")
|
|
if err != nil {
|
|
t.Fatalf("Generate() error: %v", err)
|
|
}
|
|
checks := []string{
|
|
"Description=Unitdore: agent (executable)",
|
|
"Type=oneshot",
|
|
"WorkingDirectory=/opt/agent",
|
|
`ExecStart=/opt/agent/bin/agent --config "/etc/my agent.toml"`,
|
|
"ExecStop=-/opt/agent/bin/agent-stop",
|
|
}
|
|
for _, check := range checks {
|
|
if !strings.Contains(content, check) {
|
|
t.Errorf("Generate() missing %q in output:\n%s", check, content)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerate_ExecutableMissingPath(t *testing.T) {
|
|
u := config.Unit{Name: "bad", Runtime: config.RuntimeExec, Enabled: true}
|
|
if _, err := Generate(u, "", ""); err == nil {
|
|
t.Error("Generate() should error when executable is empty")
|
|
}
|
|
}
|