package installation import ( "bytes" "context" "encoding/xml" "io" "os" "os/exec" "path/filepath" "runtime" "strings" "testing" ) func TestSystemdDefinitionAcceptedByNativeValidator(t *testing.T) { if runtime.GOOS != "linux" { t.Skip("systemd validation requires Linux") } validator, err := exec.LookPath("systemd-analyze") if err != nil { t.Skip("systemd-analyze is not installed") } dir := filepath.Join(t.TempDir(), `directory with "quotes" 100% $USER`) if err := os.Mkdir(dir, 0700); err != nil { t.Fatal(err) } d := serviceDefinition{Binary: "/bin/true", Directory: dir, Args: []string{"-db", filepath.Join(dir, "data.db")}, Environment: map[string]string{"PATH": "/usr/bin:/bin"}} text, err := d.render("linux") if err != nil { t.Fatal(err) } path := filepath.Join(t.TempDir(), "pipelines.service") if err := os.WriteFile(path, []byte(text), 0600); err != nil { t.Fatal(err) } if output, err := exec.Command(validator, "verify", path).CombinedOutput(); err != nil { t.Fatalf("systemd rejected generated definition: %v\n%s\n%s", err, output, text) } } func TestServiceDefinitionsQuotePathsAndKeepEnvironmentLimited(t *testing.T) { d := serviceDefinition{Binary: `/some bin/server`, Directory: `/repo "quoted" 100% $USER`, Args: []string{"-db", `/repo "quoted" 100% $USER/data.db`}, Environment: map[string]string{"PATH": "/usr/bin:/custom bin", "PIPELINES_NTFY_TOKEN_FILE": "/secret & token", "PROVIDER_SECRET": "must-not-export"}} for _, platform := range []string{"linux", "darwin"} { text, err := d.render(platform) if err != nil { t.Fatal(err) } if strings.Contains(text, "must-not-export") || !strings.Contains(text, serviceMarker) { t.Fatal("unexpected credentials or missing marker", text) } if platform == "linux" { if !strings.Contains(text, "\nWorkingDirectory=/repo \"quoted\" 100%% $USER\n") { t.Fatal("WorkingDirectory must be an unquoted absolute path", text) } if !strings.Contains(text, `"/some bin/server"`) || !strings.Contains(text, `100%% $$USER`) || !strings.Contains(text, `Environment="PATH=/usr/bin:/custom bin"`) { t.Fatal("unsafe systemd escaping", text) } } else { decoder := xml.NewDecoder(strings.NewReader(text)) for { _, err := decoder.Token() if err == io.EOF { break } if err != nil { t.Fatal("invalid launchd XML", err) } } if !strings.Contains(text, "/secret & token") { t.Fatal("missing XML escaping", text) } } } d.Args = []string{"newline\ninjection"} if _, err := d.render("linux"); err == nil { t.Fatal("accepted newline injection") } } func TestServiceWritesRefuseUnmanagedFilesAndSymlinks(t *testing.T) { dir := t.TempDir() path := filepath.Join(dir, "pipelines.service") if err := os.WriteFile(path, []byte("user service"), 0600); err != nil { t.Fatal(err) } if err := writeServiceFile(path, serviceMarker); err == nil { t.Fatal("replaced unmanaged file") } if err := os.Remove(path); err != nil { t.Fatal(err) } if err := os.Symlink(filepath.Join(dir, "unrelated"), path); err != nil { t.Fatal(err) } if err := writeServiceFile(path, serviceMarker); err == nil { t.Fatal("replaced symlink") } if err := os.Remove(path); err != nil { t.Fatal(err) } for i := 0; i < 2; i++ { if err := writeServiceFile(path, serviceMarker+"\nupdated"); err != nil { t.Fatal(err) } } info, err := os.Stat(path) if err != nil || info.Mode().Perm() != 0600 { t.Fatal("service file must be private", err) } } func TestServiceConfigurationPreviewAndLifecycleWithMockOSManager(t *testing.T) { if runtime.GOOS != "darwin" && runtime.GOOS != "linux" { t.Skip("no supported OS manager") } home := t.TempDir() bin := filepath.Join(home, "bin") for _, dir := range []string{bin} { if err := os.MkdirAll(dir, 0700); err != nil { t.Fatal(err) } } t.Setenv("HOME", home) t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, "config")) t.Setenv("XDG_DATA_HOME", filepath.Join(home, "data")) t.Setenv("PATH", bin) t.Setenv("PIPELINES_NTFY_TOKEN", "") server := filepath.Join(bin, "pipelines-server") if err := os.WriteFile(server, []byte("#!/bin/sh\nexit 0\n"), 0700); err != nil { t.Fatal(err) } manager := "systemctl" if runtime.GOOS == "darwin" { manager = "launchctl" } capture := filepath.Join(home, "manager-commands") if err := os.WriteFile(filepath.Join(bin, manager), []byte("#!/bin/sh\nprintf '%s\\n' \"$*\" >> '"+capture+"'\n"), 0700); err != nil { t.Fatal(err) } var out bytes.Buffer ctx := context.Background() path, err := serviceFile(runtime.GOOS) if err != nil { t.Fatal(err) } args := []string{"enable"} if err := ServiceCommand(ctx, server, append(args, "--print"), &out, &out); err != nil { t.Fatal(err) } if _, err := os.Lstat(path); !os.IsNotExist(err) { t.Fatal("preview wrote service file", err) } if _, err := os.Lstat(capture); !os.IsNotExist(err) { t.Fatal("preview invoked OS manager", err) } for i := 0; i < 2; i++ { if err := ServiceCommand(ctx, server, args, &out, &out); err != nil { t.Fatal(err) } } if err := verifyServiceFile(path); err != nil { t.Fatal(err) } if err := Uninstall(server, []string{"--yes"}, strings.NewReader(""), &out); err == nil || !strings.Contains(err.Error(), "service disable") { t.Fatal("uninstall must refuse registered service", err) } if err := ServiceCommand(ctx, server, []string{"status"}, &out, &out); err != nil { t.Fatal(err) } if err := ServiceCommand(ctx, server, []string{"disable"}, &out, &out); err != nil { t.Fatal(err) } if _, err := os.Lstat(path); !os.IsNotExist(err) { t.Fatal("disable left definition", err) } commands, err := os.ReadFile(capture) if err != nil { t.Fatal(err) } for _, command := range map[string][]string{"linux": {"daemon-reload", "enable pipelines.service", "restart pipelines.service", "status pipelines.service", "disable --now pipelines.service"}, "darwin": {"enable gui/", "bootstrap gui/", "print gui/", "disable gui/", "bootout gui/"}}[runtime.GOOS] { if !strings.Contains(string(commands), command) { t.Fatal("missing OS manager operation", command, string(commands)) } } }