diff options
Diffstat (limited to 'internal/io/journal/testhelper/mock.go')
| -rw-r--r-- | internal/io/journal/testhelper/mock.go | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/internal/io/journal/testhelper/mock.go b/internal/io/journal/testhelper/mock.go new file mode 100644 index 0000000..709c097 --- /dev/null +++ b/internal/io/journal/testhelper/mock.go @@ -0,0 +1,397 @@ +package journaltest + +import ( + "fmt" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +const ( + journalctlCommand = "journalctl" + + // TermSentinel is written to stderr when the mock receives SIGTERM. + TermSentinel = "journalctl mock received SIGTERM" +) + +// Invocation describes one journalctl mock execution scenario. +type Invocation struct { + Lines []string + FollowLines []string + Stderr []string + ExitCode int + FailFirst int + FailExitCode int + NoEntries bool + PartialLine string + LongLineLength int + InterLineDelay time.Duration + HoldOpen bool + IgnoreSIGTERM bool +} + +// Scenario configures the journalctl mock. Unit-specific invocations are chosen +// from the parsed "-u UNIT" flag; Default is used when no unit matches. +type Scenario struct { + Default Invocation + Units map[string]Invocation +} + +// Mock describes an installed journalctl mock and its recorded state files. +type Mock struct { + BinDir string + StateDir string + Path string + ArgsFile string + UnitFile string + FollowFile string + CountFile string + OutputFile string + TermFile string + PIDFile string +} + +// InstallMock installs a journalctl shell-script mock into PATH for the test. +func InstallMock(t testing.TB, scenario Scenario) *Mock { + t.Helper() + + rootDir := t.TempDir() + binDir := filepath.Join(rootDir, "bin") + stateDir := filepath.Join(rootDir, "state") + if err := os.Mkdir(binDir, 0o700); err != nil { + t.Fatalf("create journalctl mock bin dir: %v", err) + } + if err := os.Mkdir(stateDir, 0o700); err != nil { + t.Fatalf("create journalctl mock state dir: %v", err) + } + + paths := writeInvocations(t, rootDir, scenario) + mock := &Mock{ + BinDir: binDir, + StateDir: stateDir, + Path: binDir + string(os.PathListSeparator) + os.Getenv("PATH"), + ArgsFile: filepath.Join(stateDir, "journalctl.args"), + UnitFile: filepath.Join(stateDir, "journalctl.units"), + FollowFile: filepath.Join(stateDir, "journalctl.follow"), + CountFile: filepath.Join(stateDir, "journalctl.counts"), + OutputFile: filepath.Join(stateDir, "journalctl.outputs"), + TermFile: filepath.Join(stateDir, "journalctl.term"), + PIDFile: filepath.Join(stateDir, "journalctl.pid"), + } + + scriptPath := filepath.Join(binDir, journalctlCommand) + if err := os.WriteFile(scriptPath, []byte(mockScript(mock, paths)), 0o700); err != nil { + t.Fatalf("write journalctl mock script: %v", err) + } + t.Setenv("PATH", mock.Path) + + return mock +} + +// Env returns environment variables needed by child processes that override PATH. +func (m *Mock) Env() map[string]string { + return map[string]string{ + "PATH": m.Path, + } +} + +// Args returns all recorded journalctl argument lines. +func (m *Mock) Args(t testing.TB) string { + t.Helper() + return readOptionalFile(t, m.ArgsFile) +} + +// Terminated reports whether the mock observed SIGTERM. +func (m *Mock) Terminated(t testing.TB) bool { + t.Helper() + return strings.TrimSpace(readOptionalFile(t, m.TermFile)) != "" +} + +// WaitForTerm waits until the mock records SIGTERM. +func (m *Mock) WaitForTerm(t testing.TB, timeout time.Duration) { + t.Helper() + + deadline := time.Now().Add(timeout) + for { + if m.Terminated(t) { + return + } + if time.Now().After(deadline) { + t.Fatalf("journalctl mock did not observe SIGTERM before timeout") + } + time.Sleep(20 * time.Millisecond) + } +} + +type invocationPaths struct { + defaultDir string + unitDirs map[string]string +} + +func writeInvocations(t testing.TB, rootDir string, scenario Scenario) invocationPaths { + t.Helper() + + paths := invocationPaths{ + defaultDir: filepath.Join(rootDir, "scenario-default"), + unitDirs: make(map[string]string, len(scenario.Units)), + } + writeInvocation(t, paths.defaultDir, scenario.Default) + + i := 0 + for unit, invocation := range scenario.Units { + dir := filepath.Join(rootDir, fmt.Sprintf("scenario-unit-%d", i)) + writeInvocation(t, dir, invocation) + paths.unitDirs[unit] = dir + i++ + } + + return paths +} + +func writeInvocation(t testing.TB, dir string, invocation Invocation) { + t.Helper() + + if err := os.Mkdir(dir, 0o700); err != nil { + t.Fatalf("create journalctl mock scenario dir: %v", err) + } + writeLinesFile(t, filepath.Join(dir, "stdout"), invocation.Lines, true) + writeLinesFile(t, filepath.Join(dir, "follow"), invocation.FollowLines, true) + writeLinesFile(t, filepath.Join(dir, "stderr"), stderrLines(invocation), true) + writeLinesFile(t, filepath.Join(dir, "partial"), []string{invocation.PartialLine}, false) + + if invocation.LongLineLength > 0 { + longLine := strings.Repeat("x", invocation.LongLineLength) + writeLinesFile(t, filepath.Join(dir, "long"), []string{longLine}, true) + } + + config := []string{ + fmt.Sprintf("exit_code=%d", invocation.ExitCode), + fmt.Sprintf("fail_first=%d", invocation.FailFirst), + fmt.Sprintf("fail_exit_code=%d", positiveExitCode(invocation.FailExitCode)), + fmt.Sprintf("delay=%s", shellDelay(invocation.InterLineDelay)), + fmt.Sprintf("hold_open=%d", boolInt(invocation.HoldOpen)), + fmt.Sprintf("ignore_term=%d", boolInt(invocation.IgnoreSIGTERM)), + } + if err := os.WriteFile(filepath.Join(dir, "config"), []byte(strings.Join(config, "\n")+"\n"), 0o600); err != nil { + t.Fatalf("write journalctl mock scenario config: %v", err) + } +} + +func stderrLines(invocation Invocation) []string { + lines := append([]string(nil), invocation.Stderr...) + if invocation.NoEntries { + lines = append(lines, "-- No entries --") + } + return lines +} + +func writeLinesFile(t testing.TB, path string, lines []string, newline bool) { + t.Helper() + + var b strings.Builder + for _, line := range lines { + b.WriteString(strings.TrimSuffix(line, "\n")) + if newline { + b.WriteByte('\n') + } + } + if err := os.WriteFile(path, []byte(b.String()), 0o600); err != nil { + t.Fatalf("write journalctl mock fixture %s: %v", path, err) + } +} + +func shellDelay(delay time.Duration) string { + if delay <= 0 { + return "" + } + return fmt.Sprintf("%.3f", delay.Seconds()) +} + +func boolInt(value bool) int { + if value { + return 1 + } + return 0 +} + +func positiveExitCode(value int) int { + if value > 0 { + return value + } + return 1 +} + +func mockScript(mock *Mock, paths invocationPaths) string { + var b strings.Builder + b.WriteString("#!/bin/sh\n") + b.WriteString("args_file=" + shellQuote(mock.ArgsFile) + "\n") + b.WriteString("unit_file=" + shellQuote(mock.UnitFile) + "\n") + b.WriteString("follow_file=" + shellQuote(mock.FollowFile) + "\n") + b.WriteString("count_file=" + shellQuote(mock.CountFile) + "\n") + b.WriteString("output_file=" + shellQuote(mock.OutputFile) + "\n") + b.WriteString("term_file=" + shellQuote(mock.TermFile) + "\n") + b.WriteString("pid_file=" + shellQuote(mock.PIDFile) + "\n") + b.WriteString("term_sentinel=" + shellQuote(TermSentinel) + "\n") + b.WriteString(scriptBody(paths)) + return b.String() +} + +func scriptBody(paths invocationPaths) string { + var b strings.Builder + b.WriteString(` +original_args="$*" +unit="" +follow=0 +count="" +output="" + +while [ "$#" -gt 0 ]; do + case "$1" in + -u) + shift + unit="$1" + ;; + -f) + follow=1 + ;; + -n) + shift + count="$1" + ;; + --output=*) + output=${1#--output=} + ;; + --output) + shift + output="$1" + ;; + esac + [ "$#" -gt 0 ] && shift +done + +printf '%s\n' "$$" > "$pid_file" +printf '%s\n' "$original_args" >> "$args_file" +printf '%s\n' "$unit" >> "$unit_file" +printf '%s\n' "$follow" >> "$follow_file" +printf '%s\n' "$count" >> "$count_file" +printf '%s\n' "$output" >> "$output_file" + +scenario_dir=`) + b.WriteString(shellQuote(paths.defaultDir)) + b.WriteString(` +case "$unit" in +`) + for unit, dir := range paths.unitDirs { + b.WriteString(" ") + b.WriteString(shellQuote(unit)) + b.WriteString(") scenario_dir=") + b.WriteString(shellQuote(dir)) + b.WriteString(" ;;\n") + } + b.WriteString(`esac + +. "$scenario_dir/config" + +invocation_file="$scenario_dir/invocations" +invocations=0 +if [ -f "$invocation_file" ]; then + invocations=$(cat "$invocation_file") +fi +invocations=$((invocations + 1)) +printf '%s\n' "$invocations" > "$invocation_file" + +sleep_pid="" + +on_term() { + printf '%s\n' "$term_sentinel" >&2 + printf 'term' > "$term_file" + if [ -n "$sleep_pid" ]; then + kill "$sleep_pid" 2>/dev/null || true + fi + if [ "$ignore_term" != "1" ]; then + exit 0 + fi +} + +trap on_term TERM + +if [ "$fail_first" -gt 0 ] && [ "$invocations" -le "$fail_first" ]; then + exit "$fail_exit_code" +fi + +interruptible_sleep() { + sleep "$1" & + sleep_pid=$! + wait "$sleep_pid" 2>/dev/null || true + sleep_pid="" +} + +sleep_delay() { + if [ -n "$delay" ]; then + interruptible_sleep "$delay" + fi +} + +emit_lines() { + file=$1 + [ -s "$file" ] || return 0 + while IFS= read -r line || [ -n "$line" ]; do + printf '%s\n' "$line" + sleep_delay + done < "$file" +} + +emit_raw() { + file=$1 + [ -s "$file" ] || return 0 + cat "$file" + sleep_delay +} + +emit_lines "$scenario_dir/stderr" >&2 +emit_lines "$scenario_dir/stdout" +emit_lines "$scenario_dir/long" +emit_raw "$scenario_dir/partial" + +if [ "$follow" = "1" ]; then + while :; do + emit_lines "$scenario_dir/follow" + if [ ! -s "$scenario_dir/follow" ]; then + if [ -n "$delay" ]; then + sleep_delay + else + interruptible_sleep 0.05 + fi + fi + done +fi + +if [ "$hold_open" = "1" ]; then + while :; do + interruptible_sleep 0.05 + done +fi + +exit "$exit_code" +`) + return b.String() +} + +func shellQuote(value string) string { + return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'" +} + +func readOptionalFile(t testing.TB, path string) string { + t.Helper() + + content, err := os.ReadFile(path) + if err != nil { + if os.IsNotExist(err) { + return "" + } + t.Fatalf("read %s: %v", path, err) + } + return string(content) +} |