e2e_misc_test.go

// Copyright 2026 HAProxy Technologies LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//	http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"syscall"
	"testing"
	"time"

	"github.com/haproxytech/gopherd/control"
	"github.com/haproxytech/gopherd/version"
)

// daemonStdout starts the daemon with a minimal config plus extraEnv, waits
// for the control socket, shuts it down, and returns everything it wrote to
// stdout. Stdout goes to a regular file rather than a pipe so cmd.Wait does
// not block on service children (sleep) that inherit the descriptor.
func daemonStdout(t *testing.T, extraEnv ...string) string {
	t.Helper()
	dir := t.TempDir()
	cfgPath := filepath.Join(dir, "gopherd.yml")
	sockPath := filepath.Join(dir, "gopherd.sock")

	config := fmt.Sprintf(`control:
  socket: %s

processes:
  - name: app
    command: sleep
    args: ["300"]
`, sockPath)
	if err := os.WriteFile(cfgPath, []byte(config), 0o644); err != nil {
		t.Fatalf("write config: %v", err)
	}

	outPath := filepath.Join(dir, "stdout")
	outFile, err := os.Create(outPath)
	if err != nil {
		t.Fatalf("create stdout file: %v", err)
	}
	defer outFile.Close()

	cmd := exec.Command(testBinary)
	cmd.Env = append(os.Environ(), "GOPHERD_CONFIG="+cfgPath, "GOPHERD_SOCKET="+sockPath)
	cmd.Env = append(cmd.Env, extraEnv...)
	cmd.Stdout = outFile
	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
	if err := cmd.Start(); err != nil {
		t.Fatalf("start: %v", err)
	}
	defer func() {
		syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
		cmd.Wait()
	}()

	deadline := time.Now().Add(10 * time.Second)
	for !control.IsAlive(sockPath) {
		if time.Now().After(deadline) {
			t.Fatal("daemon did not start")
		}
		time.Sleep(50 * time.Millisecond)
	}

	cmd.Process.Signal(syscall.SIGTERM)
	cmd.Wait()

	stdout, err := os.ReadFile(outPath)
	if err != nil {
		t.Fatalf("read stdout file: %v", err)
	}
	return string(stdout)
}

func TestE2ELogoPrintedByDefault(t *testing.T) {
	stdout := daemonStdout(t)
	if !strings.Contains(stdout, version.Logo) {
		t.Errorf("logo not printed on startup:\n%s", stdout)
	}
}

func TestE2ELogoSuppressedByEnv(t *testing.T) {
	// Env suppression keeps test configs free of test-only flags.
	stdout := daemonStdout(t, "GOPHERD_NO_LOGO=1")
	if strings.Contains(stdout, version.Logo) {
		t.Errorf("logo printed despite GOPHERD_NO_LOGO=1:\n%s", stdout)
	}
}

func TestE2EPassthrough(t *testing.T) {
	// When invoked with a non-client command, gopherd should exec it directly.
	cmd := exec.Command(testBinary, "echo", "hello-passthrough")
	out, err := cmd.Output()
	if err != nil {
		t.Fatalf("passthrough exec failed: %v", err)
	}
	if !strings.Contains(string(out), "hello-passthrough") {
		t.Errorf("expected passthrough output, got: %s", out)
	}
}

// TestE2EPassthroughSeparatorNotInArgv pins the exact argv of a passthrough
// exec carrying entrypoint args after "--". The separator is a gopherd-level
// delimiter, not an argument: leaking it shifts every positional parameter by
// one ($0 becomes "--") and breaks entrypoint scripts that read "$1". Only an
// exact-argv assertion catches it; "contains the args" passes either way.
func TestE2EPassthroughSeparatorNotInArgv(t *testing.T) {
	out := filepath.Join(t.TempDir(), "argv")
	cmd := exec.Command(testBinary, "/bin/sh", "-c",
		fmt.Sprintf(`printf '%%s|' "$0" "$@" > %s`, out), "--", "alpha", "beta")
	if err := cmd.Run(); err != nil {
		t.Fatalf("passthrough exec failed: %v", err)
	}
	data, err := os.ReadFile(out)
	if err != nil {
		t.Fatalf("read argv capture: %v", err)
	}
	// sh -c <script> alpha beta  =>  $0=alpha, $@=(beta)
	if got, want := string(data), "alpha|beta|"; got != want {
		t.Errorf("passthrough argv = %q, want %q (the -- separator must be "+
			"consumed by gopherd, never forwarded to the program)", got, want)
	}
}

// TestE2EInitStopSignalLogIsDeterministic pins the signal-set log line. The set
// is a map, so it has to be sorted or the startup banner flaps between runs,
// breaking golden comparisons and log parsers. One run proves nothing — chance
// prints sorted order often enough — so the line must be identical across
// repeated starts.
func TestE2EInitStopSignalLogIsDeterministic(t *testing.T) {
	const config = `
init-stop-signal: [SIGTERM, SIGQUIT, SIGUSR2, SIGINT]

processes:
  - name: app
    command: sleep
    args: ["300"]
    on-success: ignore
    on-failure: ignore
`
	// formatSignalSet sorts by signal number: INT(2), QUIT(3), USR2(12), TERM(15).
	const want = "init-stop-signal: SIGINT, SIGQUIT, SIGUSR2, SIGTERM"

	for i := range 5 {
		td := startDaemon(t, config)
		td.WaitRunning("app", 10*time.Second)
		out := td.Output()
		td.kill()

		var line string
		for l := range strings.SplitSeq(out, "\n") {
			if strings.Contains(l, "init-stop-signal:") {
				line = strings.TrimSpace(strings.TrimPrefix(l, "gopherd: "))
			}
		}
		if line == "" {
			t.Fatalf("run %d: no init-stop-signal line in output: %s", i, out)
		}
		if line != want {
			t.Fatalf("run %d: init-stop-signal line = %q, want %q "+
				"(the set must be rendered in a stable order)", i, line, want)
		}
	}
}

func TestE2EPassthroughNotFound(t *testing.T) {
	cmd := exec.Command(testBinary, "nonexistent-binary-xyz")
	cmd.Stderr = nil
	err := cmd.Run()
	if err == nil {
		t.Fatal("expected error for nonexistent passthrough command")
	}
	exitErr, ok := err.(*exec.ExitError)
	if !ok {
		t.Fatalf("expected ExitError, got: %v", err)
	}
	if exitErr.ExitCode() != 1 {
		t.Errorf("expected exit code 1, got %d", exitErr.ExitCode())
	}
}

// Passthrough execs the target, so its status must reach the caller verbatim.
// 1 is gopherd's own error code, so probe a different value.
func TestE2EPassthroughExitCode(t *testing.T) {
	err := exec.Command(testBinary, "/bin/sh", "-c", "exit 42").Run()
	exitErr, ok := err.(*exec.ExitError)
	if !ok {
		t.Fatalf("expected ExitError with code 42, got: %v", err)
	}
	if exitErr.ExitCode() != 42 {
		t.Errorf("exit code = %d, want 42 (passthrough must not mask the child's status)", exitErr.ExitCode())
	}
}

func TestE2EVersionCommand(t *testing.T) {
	cmd := exec.Command(testBinary, "version")
	out, err := cmd.Output()
	if err != nil {
		t.Fatalf("version command failed: %v", err)
	}
	if !strings.Contains(string(out), "gopherd") {
		t.Errorf("expected 'gopherd' in version output, got: %s", out)
	}
}

func TestE2EAlreadyRunning(t *testing.T) {
	td := startDaemon(t, `
processes:
  - name: app
    command: sleep
    args: ["300"]
    on-failure: shutdown
`)
	defer td.kill()

	// Start a second instance with the same socket — it should detect the running daemon and exit.
	cmd := exec.Command(testBinary)
	cmd.Env = append(os.Environ(), "GOPHERD_CONFIG="+td.ConfigPath(), "GOPHERD_SOCKET="+td.SocketPath())
	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
	err := cmd.Run()
	if err == nil {
		t.Fatal("expected second instance to exit with error")
	}
	exitErr, ok := err.(*exec.ExitError)
	if !ok {
		t.Fatalf("expected ExitError, got: %v", err)
	}
	if exitErr.ExitCode() != 1 {
		t.Errorf("expected exit code 1 for already-running, got %d", exitErr.ExitCode())
	}

	td.stop()
}