narratio/internal/adapters/subprocess/run_test.go

package subprocess

import (
	"bytes"
	"context"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"testing"
	"time"

	"gopkg.in/yaml.v3"
)

func TestRunSuccessCapturesStdoutStderr(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	dir := t.TempDir()
	stdoutPath := filepath.Join(dir, "stdout.log")
	stderrPath := filepath.Join(dir, "stderr.log")
	req := RunRequest{
		Executable:    exe,
		Args:          []string{"-test.run=TestSubprocessHelper", "--", "success"},
		EnvOverrides:  map[string]string{"GO_WANT_SUBPROCESS_HELPER": "1", "SUBPROCESS_HELPER_STDOUT": "hello-out", "SUBPROCESS_HELPER_STDERR": "hello-err"},
		StdoutLogPath: stdoutPath,
		StderrLogPath: stderrPath,
	}

	res, err := Run(context.Background(), req)
	if err != nil {
		t.Fatalf("Run() error = %v", err)
	}
	if res.ExitCode != 0 {
		t.Fatalf("ExitCode = %d, want 0", res.ExitCode)
	}

	stdoutBytes, err := os.ReadFile(stdoutPath)
	if err != nil {
		t.Fatalf("read stdout log: %v", err)
	}
	if !strings.Contains(string(stdoutBytes), "hello-out") {
		t.Fatalf("stdout log = %q, want hello-out", string(stdoutBytes))
	}

	stderrBytes, err := os.ReadFile(stderrPath)
	if err != nil {
		t.Fatalf("read stderr log: %v", err)
	}
	if !strings.Contains(string(stderrBytes), "hello-err") {
		t.Fatalf("stderr log = %q, want hello-err", string(stderrBytes))
	}
}

func TestRunFailureReturnsUsefulError(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	dir := t.TempDir()
	stdoutPath := filepath.Join(dir, "stdout.log")
	stderrPath := filepath.Join(dir, "stderr.log")
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "fail"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
		},
		StdoutLogPath: stdoutPath,
		StderrLogPath: stderrPath,
	}

	res, err := Run(context.Background(), req)
	if err == nil {
		t.Fatal("Run() error = nil, want non-nil")
	}
	if res.ExitCode == 0 {
		t.Fatalf("ExitCode = %d, want non-zero", res.ExitCode)
	}
	if !strings.Contains(err.Error(), "exit code") {
		t.Fatalf("error = %q, want exit code context", err.Error())
	}
	if !strings.Contains(err.Error(), exe) {
		t.Fatalf("error = %q, want executable context", err.Error())
	}
	if !strings.Contains(err.Error(), stdoutPath) || !strings.Contains(err.Error(), stderrPath) {
		t.Fatalf("error = %q, want stdout/stderr log paths", err.Error())
	}
}

func TestRunFailureRedactsSensitiveTail(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	secretValue := "super-secret-value"
	dir := t.TempDir()
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "failsecret"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
			"API_KEY":                   secretValue,
			"SUBPROCESS_HELPER_ENV_KEY": "API_KEY",
		},
		StdoutLogPath: filepath.Join(dir, "stdout.log"),
		StderrLogPath: filepath.Join(dir, "stderr.log"),
	}

	_, err = Run(context.Background(), req)
	if err == nil {
		t.Fatal("Run() error = nil, want non-nil")
	}
	if strings.Contains(err.Error(), secretValue) {
		t.Fatalf("error leaked secret value: %q", err.Error())
	}
	if !strings.Contains(err.Error(), "<redacted>") {
		t.Fatalf("error = %q, want redacted stderr tail marker", err.Error())
	}
	for _, path := range []string{req.StdoutLogPath, req.StderrLogPath} {
		data, readErr := os.ReadFile(path)
		if readErr != nil {
			t.Fatalf("read diagnostic %q: %v", path, readErr)
		}
		if strings.Contains(string(data), secretValue) {
			t.Fatalf("diagnostic %q leaked secret: %q", path, data)
		}
	}
}

func TestRunRedactsInheritedSensitiveEnvironment(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}
	secretValue := "inherited-secret-value"
	t.Setenv("OPENROUTER_API_KEY", secretValue)
	dir := t.TempDir()
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "echoenv"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
			"SUBPROCESS_HELPER_ENV_KEY": "OPENROUTER_API_KEY",
		},
		StdoutLogPath: filepath.Join(dir, "stdout.log"),
		StderrLogPath: filepath.Join(dir, "stderr.log"),
	}
	_, err = Run(context.Background(), req)
	if err == nil {
		t.Fatal("Run() error = nil, want non-nil")
	}
	if strings.Contains(err.Error(), secretValue) {
		t.Fatalf("error leaked inherited secret: %q", err)
	}
	for _, path := range []string{req.StdoutLogPath, req.StderrLogPath} {
		data, readErr := os.ReadFile(path)
		if readErr != nil {
			t.Fatalf("read diagnostic %q: %v", path, readErr)
		}
		if strings.Contains(string(data), secretValue) {
			t.Fatalf("diagnostic %q leaked inherited secret: %q", path, data)
		}
	}
}

func TestRunRedactsSensitiveOutputAndErrorTail(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}
	secretValue := "override-secret-value"
	dir := t.TempDir()
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "echoenv"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
			"SUBPROCESS_HELPER_ENV_KEY": "OPENROUTER_API_KEY",
			"OPENROUTER_API_KEY":        secretValue,
		},
		StdoutLogPath: filepath.Join(dir, "stdout.log"),
		StderrLogPath: filepath.Join(dir, "stderr.log"),
	}
	_, err = Run(context.Background(), req)
	if err == nil {
		t.Fatal("Run() error = nil, want non-nil")
	}
	if strings.Contains(err.Error(), secretValue) || !strings.Contains(err.Error(), "<redacted>") {
		t.Fatalf("error = %q, want redacted secret", err)
	}
	for _, path := range []string{req.StdoutLogPath, req.StderrLogPath} {
		data, readErr := os.ReadFile(path)
		if readErr != nil {
			t.Fatalf("read diagnostic %q: %v", path, readErr)
		}
		if strings.Contains(string(data), secretValue) || !strings.Contains(string(data), "<redacted>") {
			t.Fatalf("diagnostic %q = %q, want redacted secret", path, data)
		}
	}
}

func TestStreamRedactorHandlesSplitAndOverlappingSecrets(t *testing.T) {
	redactor := newStreamRedactor([]string{"abc", "abcde", "cde", ""})
	var output bytes.Buffer
	output.Write(redactor.Write([]byte("start-ab")))
	output.Write(redactor.Write([]byte("cde-end")))
	output.Write(redactor.Flush())
	if got := output.String(); got != "start-<redacted>-end" {
		t.Fatalf("redacted output = %q, want one redacted marker", got)
	}
}

func TestDiagnosticWriterHonorsExactLimitAndCapPlusOne(t *testing.T) {
	exactLogs := &logWriters{limits: make(chan *captureLimitError, 1)}
	var exactOutput bytes.Buffer
	exact := newDiagnosticWriter(exactLogs, "stdout", "test", &exactOutput, 5, nil)
	if _, err := exact.Write([]byte("abcde")); err != nil {
		t.Fatalf("exact Write() error = %v", err)
	}
	if err := exact.Flush(); err != nil {
		t.Fatalf("exact Flush() error = %v", err)
	}
	if got := exactOutput.String(); got != "abcde" {
		t.Fatalf("exact output = %q, want abcde", got)
	}
	if exactLogs.Limit() != nil {
		t.Fatal("exact write recorded a capture limit")
	}

	cappedLogs := &logWriters{limits: make(chan *captureLimitError, 1)}
	var cappedOutput bytes.Buffer
	capped := newDiagnosticWriter(cappedLogs, "stderr", "test", &cappedOutput, 5, nil)
	if _, err := capped.Write([]byte("abcdef")); err == nil {
		t.Fatal("cap-plus-one Write() error = nil, want capture limit")
	}
	if err := capped.Flush(); err != nil {
		t.Fatalf("cap-plus-one Flush() error = %v", err)
	}
	if got := cappedOutput.String(); got != "abcde" {
		t.Fatalf("capped output = %q, want abcde", got)
	}
	if limit := cappedLogs.Limit(); limit == nil || limit.stream != "stderr" || limit.limit != 5 {
		t.Fatalf("capture limit = %#v, want stderr limit 5", limit)
	}
}

func TestRunFailureAddsBadDescriptorHint(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	dir := t.TempDir()
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "failbadfd"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
		},
		StdoutLogPath: filepath.Join(dir, "stdout.log"),
		StderrLogPath: filepath.Join(dir, "stderr.log"),
	}

	_, err = Run(context.Background(), req)
	if err == nil {
		t.Fatal("Run() error = nil, want non-nil")
	}
	if !strings.Contains(err.Error(), "Bad file descriptor") {
		t.Fatalf("error = %q, want stderr tail content", err.Error())
	}
	if !strings.Contains(err.Error(), "stderr stream appears invalid in child process") {
		t.Fatalf("error = %q, want bad-descriptor hint", err.Error())
	}
}

func TestRunTimeout(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "sleep"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
		},
		Timeout: 50 * time.Millisecond,
	}

	res, err := Run(context.Background(), req)
	if err == nil {
		t.Fatal("Run() error = nil, want timeout error")
	}
	if !res.TimedOut {
		t.Fatalf("TimedOut = %v, want true", res.TimedOut)
	}
	if !strings.Contains(err.Error(), "timed out") {
		t.Fatalf("error = %q, want timeout context", err.Error())
	}
}

func TestRunInheritsParentEnvironmentByDefault(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	t.Setenv("PATH", "inherited-value")

	dir := t.TempDir()
	stdoutPath := filepath.Join(dir, "stdout.log")
	req := RunRequest{
		Executable:    exe,
		Args:          []string{"-test.run=TestSubprocessHelper", "--", "printenv"},
		EnvOverrides:  map[string]string{"GO_WANT_SUBPROCESS_HELPER": "1", "SUBPROCESS_HELPER_ENV_KEY": "PATH"},
		StdoutLogPath: stdoutPath,
	}

	if _, err := Run(context.Background(), req); err != nil {
		t.Fatalf("Run() error = %v", err)
	}
	data, err := os.ReadFile(stdoutPath)
	if err != nil {
		t.Fatalf("read stdout log: %v", err)
	}
	if strings.TrimSpace(string(data)) != "inherited-value" {
		t.Fatalf("stdout = %q, want inherited-value", strings.TrimSpace(string(data)))
	}
}

func TestRunEnvOverridesWinOverInheritedValues(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	dir := t.TempDir()
	stdoutPath := filepath.Join(dir, "stdout.log")
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "printenv"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
			"SUBPROCESS_HELPER_ENV_KEY": "SUBPROCESS_PARENT_VALUE",
			"SUBPROCESS_PARENT_VALUE":   "override-value",
		},
		StdoutLogPath: stdoutPath,
	}

	if _, err := Run(context.Background(), req); err != nil {
		t.Fatalf("Run() error = %v", err)
	}
	data, err := os.ReadFile(stdoutPath)
	if err != nil {
		t.Fatalf("read stdout log: %v", err)
	}
	if strings.TrimSpace(string(data)) != "override-value" {
		t.Fatalf("stdout = %q, want override-value", strings.TrimSpace(string(data)))
	}
}

func TestRunSharedStdoutStderrLogPath(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Fatalf("os.Executable() error = %v", err)
	}

	dir := t.TempDir()
	sharedLogPath := filepath.Join(dir, "shared.log")
	req := RunRequest{
		Executable: exe,
		Args:       []string{"-test.run=TestSubprocessHelper", "--", "success"},
		EnvOverrides: map[string]string{
			"GO_WANT_SUBPROCESS_HELPER": "1",
			"SUBPROCESS_HELPER_STDOUT":  "shared-out",
			"SUBPROCESS_HELPER_STDERR":  "shared-err",
		},
		StdoutLogPath: sharedLogPath,
		StderrLogPath: sharedLogPath,
	}

	res, err := Run(context.Background(), req)
	if err != nil {
		t.Fatalf("Run() error = %v", err)
	}
	if res.ExitCode != 0 {
		t.Fatalf("ExitCode = %d, want 0", res.ExitCode)
	}
	data, err := os.ReadFile(sharedLogPath)
	if err != nil {
		t.Fatalf("read shared log: %v", err)
	}
	text := string(data)
	if !strings.Contains(text, "shared-out") || !strings.Contains(text, "shared-err") {
		t.Fatalf("shared log = %q, want both stdout and stderr content", text)
	}
}

func TestWriteYAMLAtomic(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "config.generated.yml")

	if err := WriteYAMLAtomic(path, map[string]any{"name": "narratio", "stage": "merge"}, 0o644); err != nil {
		t.Fatalf("WriteYAMLAtomic() error = %v", err)
	}

	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read yaml: %v", err)
	}

	var got map[string]any
	if err := yaml.Unmarshal(data, &got); err != nil {
		t.Fatalf("yaml unmarshal: %v", err)
	}
	if got["name"] != "narratio" {
		t.Fatalf("name = %#v, want narratio", got["name"])
	}
}

func TestWriteYAMLAtomicOverwriteNoTempResidue(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "config.generated.yml")

	if err := WriteYAMLAtomic(path, map[string]any{"value": "one"}, 0o644); err != nil {
		t.Fatalf("first write: %v", err)
	}
	if err := WriteYAMLAtomic(path, map[string]any{"value": "two"}, 0o644); err != nil {
		t.Fatalf("second write: %v", err)
	}

	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read yaml: %v", err)
	}
	if !strings.Contains(string(data), "two") {
		t.Fatalf("yaml = %q, want overwritten value", string(data))
	}

	entries, err := os.ReadDir(dir)
	if err != nil {
		t.Fatalf("ReadDir() error = %v", err)
	}
	for _, entry := range entries {
		name := entry.Name()
		if strings.Contains(name, ".tmp-") {
			t.Fatalf("temp file residue found: %q", name)
		}
	}
}

func TestSubprocessHelper(t *testing.T) {
	if os.Getenv("GO_WANT_SUBPROCESS_HELPER") != "1" {
		return
	}

	args := os.Args
	mode := ""
	for i := range args {
		if args[i] == "--" && i+1 < len(args) {
			mode = args[i+1]
			break
		}
	}
	if mode == "" {
		os.Exit(2)
	}

	switch mode {
	case "success":
		_, _ = os.Stdout.WriteString(os.Getenv("SUBPROCESS_HELPER_STDOUT") + "\n")
		_, _ = os.Stderr.WriteString(os.Getenv("SUBPROCESS_HELPER_STDERR") + "\n")
		os.Exit(0)
	case "fail":
		_, _ = os.Stderr.WriteString("intentional failure\n")
		os.Exit(3)
	case "failsecret":
		key := os.Getenv("SUBPROCESS_HELPER_ENV_KEY")
		_, _ = os.Stderr.WriteString("secret:" + os.Getenv(key) + "\n")
		os.Exit(4)
	case "failbadfd":
		_, _ = os.Stderr.WriteString("OSError: [Errno 9] Bad file descriptor\n")
		os.Exit(120)
	case "sleep":
		time.Sleep(500 * time.Millisecond)
		os.Exit(0)
	case "printenv":
		key := os.Getenv("SUBPROCESS_HELPER_ENV_KEY")
		_, _ = os.Stdout.WriteString(os.Getenv(key) + "\n")
		os.Exit(0)
	case "echoenv":
		key := os.Getenv("SUBPROCESS_HELPER_ENV_KEY")
		value := os.Getenv(key)
		_, _ = os.Stdout.WriteString(value)
		_, _ = os.Stderr.WriteString(value)
		os.Exit(5)
	case "spam":
		chunk := strings.Repeat("x", 64*1024)
		count, _ := strconv.Atoi(os.Getenv("SUBPROCESS_HELPER_CHUNKS"))
		for range count {
			_, _ = os.Stdout.WriteString(chunk)
		}
		os.Exit(0)
	case "tree-spam":
		descendant := exec.Command(os.Args[0], "-test.run=^TestSubprocessHelper$", "--", "descendant")
		descendant.Env = append(os.Environ(), "GO_WANT_SUBPROCESS_HELPER=1")
		descendant.Stdout = os.Stdout
		descendant.Stderr = os.Stderr
		if err := descendant.Start(); err != nil {
			os.Exit(3)
		}
		if err := os.WriteFile(os.Getenv("SUBPROCESS_HELPER_READY_PATH"), []byte("ready"), 0o600); err != nil {
			os.Exit(4)
		}
		chunk := strings.Repeat("x", 64*1024)
		for {
			_, _ = os.Stdout.WriteString(chunk)
		}
	case "tree":
		descendant := exec.Command(os.Args[0], "-test.run=^TestSubprocessHelper$", "--", "descendant")
		descendant.Env = append(os.Environ(), "GO_WANT_SUBPROCESS_HELPER=1")
		descendant.Stdout = os.Stdout
		descendant.Stderr = os.Stderr
		if err := descendant.Start(); err != nil {
			os.Exit(3)
		}
		if err := os.WriteFile(os.Getenv("SUBPROCESS_HELPER_READY_PATH"), []byte("ready"), 0o600); err != nil {
			os.Exit(4)
		}
		time.Sleep(10 * time.Second)
		os.Exit(0)
	case "descendant":
		time.Sleep(500 * time.Millisecond)
		_ = os.WriteFile(os.Getenv("SUBPROCESS_HELPER_SENTINEL_PATH"), []byte("survived"), 0o600)
		time.Sleep(10 * time.Second)
		os.Exit(0)
	default:
		os.Exit(2)
	}
}