mire
Code Issues

feat: move to custom screen impl

Browse Source
This commit is contained in:
ruinivist
2026-03-21 19:22:56 +00:00
parent dfe47846af
commit 07b5f59c2c
13 changed files with 762 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/mire/post_process.go
+4
View File
@@ -35,6 +35,10 @@ func loadRecordedOutput(path string) ([]byte, error) {
return nil, err
}
if !hasScriptWrapper(data) {
return data, nil
}
return stripScriptWrapper(data)
}
internal/mire/record_session.go
+28 -5
View File
@@ -9,6 +9,7 @@ import (
"strings"
"mire/internal/output"
"mire/internal/screen"
)
type recordIO struct {
@@ -120,13 +121,35 @@ func newRecordSandboxForPathEnv(pathEnv string) (recordSandbox, func(), error) {
}
func runRecordSession(dir, rawIn, rawOut, shellPath string, sandbox recordSandbox, rio recordIO, sandboxConfig map[string]string, setupScripts []string) error {
cmd := exec.Command("script", "-q", "-E", "always", "-I", rawIn, "-O", rawOut, "-c", shellPath)
rawInFile, err := os.Create(rawIn)
if err != nil {
return err
}
defer rawInFile.Close()
rawOutFile, err := os.Create(rawOut)
if err != nil {
return err
}
defer rawOutFile.Close()
cmd := exec.Command(shellPath)
cmd.Dir = dir
cmd.Env = recordSessionEnv(sandbox, sandboxConfig, setupScripts)
cmd.Stdin = rio.in
cmd.Stdout = rio.out
cmd.Stderr = rio.err
return cmd.Run()
var tty *os.File
if file, ok := rio.in.(*os.File); ok {
tty = file
}
return screen.Record(screen.RecordRequest{
Cmd: cmd,
Input: rio.in,
Output: rio.out,
TTY: tty,
InputLog: rawInFile,
OutputLog: rawOutFile,
})
}
func confirmRecordOverwrite(target string, rio recordIO) (bool, error) {
internal/mire/record_test.go
+44 -105
View File
@@ -1,13 +1,11 @@
package mire
import (
"bytes"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"time"
"mire/internal/testutil"
)
@@ -18,15 +16,18 @@ func TestRecordCreatesRelativePath(t *testing.T) {
testutil.MustMkdirAll(t, testDir)
testutil.WriteFile(t, filepath.Join(root, "mire.toml"), testutil.ValidConfigContent("e2e"))
mustWriteRecordShell(t, testDir)
testutil.AddFakeRecordDependencies(t, "script")
testutil.AddFakeRecordDependencies(t, "bwrap", "bash")
got := testutil.WithWorkingDir(t, root, func() string {
testutil.WithStdin(t, "y\n", func() {})
path, err := Record(filepath.Join("a", "b", "c") + string(os.PathSeparator))
if err != nil {
t.Fatalf("Record() error = %v", err)
}
return path
var got string
testutil.WithWorkingDir(t, root, func() struct{} {
testutil.CapturePromptedOutput(t, "exit\n", "Save recording?", "y\n", func() {
path, err := Record(filepath.Join("a", "b", "c") + string(os.PathSeparator))
if err != nil {
t.Fatalf("Record() error = %v", err)
}
got = path
})
return struct{}{}
})
want := filepath.Join(testDir, "a", "b", "c")
@@ -40,11 +41,11 @@ func TestRecordCreatesRelativePath(t *testing.T) {
}
}
if got := testutil.ReadFile(t, filepath.Join(want, "in")); got != "fake recorded input\n" {
t.Fatalf("saved in = %q, want %q", got, "fake recorded input\n")
if got := testutil.ReadFile(t, filepath.Join(want, "in")); got != "exit\n" {
t.Fatalf("saved in = %q, want %q", got, "exit\n")
}
if got := testutil.ReadFile(t, filepath.Join(want, "out")); got != "fake recorded output\n" {
t.Fatalf("saved out = %q, want %q", got, "fake recorded output\n")
if got := testutil.ReadFile(t, filepath.Join(want, "out")); got != "exit\r\nexit\r\n" {
t.Fatalf("saved out = %q, want %q", got, "exit\\r\\nexit\\r\\n")
}
}
@@ -53,12 +54,12 @@ func TestRecordReturnsDiscardedErrorWhenSaveDeclined(t *testing.T) {
testDir := filepath.Join(root, "e2e")
testutil.MustMkdirAll(t, testDir)
mustWriteRecordShell(t, testDir)
testutil.AddFakeRecordDependencies(t, "script")
testutil.AddFakeRecordDependencies(t, "bwrap", "bash")
err := testutil.WithWorkingDir(t, root, func() error {
target := filepath.Join(testDir, "a", "b", "c")
testutil.MustMkdirAll(t, target)
return withRecordStreams(t, "n\n", func(rio recordIO) error {
return withRecordStreams(t, "exit\nn\n", func(rio recordIO) error {
return recordScenario(target, recordShellPath(testDir), rio, defaultSandboxConfig(), nil)
})
})
@@ -81,7 +82,6 @@ func TestRecordReturnsDiscardedErrorWhenOverwriteDeclined(t *testing.T) {
target := filepath.Join(testDir, "a", "b", "c")
testutil.MustMkdirAll(t, target)
mustWriteRecordShell(t, testDir)
testutil.AddFakeRecordDependencies(t, "script")
testutil.WriteFile(t, filepath.Join(target, "in"), "existing in\n")
testutil.WriteFile(t, filepath.Join(target, "out"), "existing out\n")
@@ -204,15 +204,12 @@ func TestRecordSessionEnvWithExtraIncludesAdditionalEntries(t *testing.T) {
}
}
func TestRunRecordSessionUsesSandboxedScriptCommand(t *testing.T) {
testDir := filepath.Join(t.TempDir(), "e2e")
mustWriteRecordShell(t, testDir)
testutil.AddFakeRecordDependencies(t, "script")
argsPath := filepath.Join(t.TempDir(), "script.args")
commandBodyPath := filepath.Join(t.TempDir(), "script.command")
t.Setenv("FAKE_SCRIPT_ARGS_FILE", argsPath)
t.Setenv("FAKE_SCRIPT_COMMAND_BODY_FILE", commandBodyPath)
func TestRunRecordSessionCapturesInputAndOutput(t *testing.T) {
shellPath := filepath.Join(t.TempDir(), "shell.sh")
testutil.WriteFile(t, shellPath, "#!/bin/sh\nprintf 'ready\\n'\nread line\nprintf 'seen:%s\\n' \"$line\"\n")
if err := os.Chmod(shellPath, 0o755); err != nil {
t.Fatalf("Chmod(%q) error = %v", shellPath, err)
}
sandbox, cleanup, err := newRecordSandboxForPathEnv(os.Getenv("PATH"))
if err != nil {
@@ -220,57 +217,29 @@ func TestRunRecordSessionUsesSandboxedScriptCommand(t *testing.T) {
}
defer cleanup()
shellPath := recordShellPath(testDir)
err = withRecordStreams(t, "", func(rio recordIO) error {
return runRecordSession(t.TempDir(), filepath.Join(t.TempDir(), "raw.in"), filepath.Join(t.TempDir(), "raw.out"), shellPath, sandbox, rio, defaultSandboxConfig(), []string{"/repo/e2e/setup.sh"})
rawIn := filepath.Join(t.TempDir(), "raw.in")
rawOut := filepath.Join(t.TempDir(), "raw.out")
err = withRecordStreams(t, "hello\n", func(rio recordIO) error {
return runRecordSession(t.TempDir(), rawIn, rawOut, shellPath, sandbox, rio, defaultSandboxConfig(), nil)
})
if err != nil {
t.Fatalf("runRecordSession() error = %v", err)
}
args := strings.Split(strings.TrimSpace(testutil.ReadFile(t, argsPath)), "\n")
if len(args) != 9 {
t.Fatalf("script args = %q, want 9 args", args)
}
if got := args[:4]; strings.Join(got, "\n") != strings.Join([]string{"-q", "-E", "always", "-I"}, "\n") {
t.Fatalf("script args prefix = %q, want %q", got, []string{"-q", "-E", "always", "-I"})
}
if args[5] != "-O" {
t.Fatalf("script args[5] = %q, want %q", args[5], "-O")
}
if args[7] != "-c" {
t.Fatalf("script args[7] = %q, want %q", args[7], "-c")
}
if args[8] != shellPath {
t.Fatalf("script args[8] = %q, want %q", args[8], shellPath)
if got := testutil.ReadFile(t, rawIn); got != "hello\n" {
t.Fatalf("raw in = %q, want %q", got, "hello\n")
}
body := testutil.ReadFile(t, commandBodyPath)
for _, want := range []string{
"host_home=${MIRE_HOST_HOME:?}",
"visible_home=${MIRE_VISIBLE_HOME:?}",
"bootstrap_rc=\"$host_home/.mire-shell-rc\"",
"visible_bootstrap_rc=\"$visible_home/.mire-shell-rc\"",
"for path in /tmp/mire-setup-scripts/*.sh; do",
"source \"$path\"",
`if [ -n "${MIRE_SETUP_SCRIPTS:-}" ]; then`,
`set -- "$@" --ro-bind "$host_path" "$visible_path"`,
`if [ "${MIRE_COMPARE_MARKER:-0}" = "1" ]; then`,
"printf '__MIRE_E2E_BEGIN__\\n'",
"--ro-bind / /",
"--tmpfs /home",
"--setenv HOME \"$visible_home\"",
"--setenv TMPDIR '/tmp'",
"exec bwrap \"$@\" bash --noprofile --rcfile \"$visible_bootstrap_rc\" -i",
} {
if !strings.Contains(body, want) {
t.Fatalf("wrapper = %q, want substring %q", body, want)
rawOutput := testutil.ReadFile(t, rawOut)
for _, want := range []string{"ready", "seen:hello"} {
if !strings.Contains(rawOutput, want) {
t.Fatalf("raw out = %q, want substring %q", rawOutput, want)
}
}
}
func TestRecordScenarioUsesDeterministicSandbox(t *testing.T) {
testutil.RequireCommands(t, "script", "bwrap", "bash")
testutil.RequireCommands(t, "bwrap", "bash")
root := t.TempDir()
testDir := filepath.Join(root, "e2e")
@@ -283,49 +252,20 @@ func TestRecordScenarioUsesDeterministicSandbox(t *testing.T) {
}
visibleHome := sandboxConfig["visible_home"]
reader, writer, err := os.Pipe()
if err != nil {
t.Fatalf("os.Pipe() error = %v", err)
}
t.Cleanup(func() {
if err := reader.Close(); err != nil {
t.Fatalf("close pipe reader: %v", err)
}
})
writeDone := make(chan error, 1)
go func() {
defer close(writeDone)
defer writer.Close()
if _, err := writer.Write([]byte("pwd\necho \"$HOME\"\necho \"$MIRE_KEY_WORD\"\nif [ -e \"$HOME/repo\" ]; then echo FOUND; else echo MISSING; fi\npwd\nexit\n")); err != nil {
writeDone <- err
return
}
time.Sleep(300 * time.Millisecond)
if _, err := writer.Write([]byte("y\n")); err != nil {
writeDone <- err
return
}
writeDone <- nil
}()
err = testutil.WithWorkingDir(t, root, func() error {
return recordScenario(target, recordShellPath(testDir), recordIO{
in: reader,
out: ioDiscard{},
err: &bytes.Buffer{},
}, sandboxConfig, nil)
err := testutil.WithWorkingDir(t, root, func() error {
return withPromptedRecordStreams(
t,
"pwd\necho \"$HOME\"\necho \"$MIRE_KEY_WORD\"\nif [ -e \"$HOME/repo\" ]; then echo FOUND; else echo MISSING; fi\npwd\nexit\n",
"y\n",
func(rio recordIO) error {
rio.out = ioDiscard{}
return recordScenario(target, recordShellPath(testDir), rio, sandboxConfig, nil)
},
)
})
if err != nil {
t.Fatalf("recordScenario() error = %v", err)
}
if err := <-writeDone; err != nil {
t.Fatalf("write session input: %v", err)
}
recordedIn := testutil.ReadFile(t, filepath.Join(target, "in"))
if strings.Contains(recordedIn, "Script started on ") {
@@ -359,7 +299,6 @@ func TestRecordFailsWhenRecorderShellMissing(t *testing.T) {
testDir := filepath.Join(root, "e2e")
testutil.WriteFile(t, filepath.Join(root, "mire.toml"), testutil.ValidConfigContent("e2e"))
testutil.MustMkdirAll(t, testDir)
testutil.AddFakeRecordDependencies(t, "script")
target := filepath.Join(testDir, "suite", "spec")
err := testutil.WithWorkingDir(t, root, func() error {
internal/mire/test.go
+16 -5
View File
@@ -13,6 +13,7 @@ import (
"time"
"mire/internal/output"
"mire/internal/screen"
)
type testIO struct {
@@ -242,18 +243,28 @@ func replayScenario(scenario testScenario, shellPath string, _ testIO, sandboxCo
}
defer cleanupSandbox()
cmd := exec.Command("script", "-q", "-E", "always", "-O", rawOut, "-c", shellPath)
rawOutFile, err := os.Create(rawOut)
if err != nil {
return fmt.Errorf("failed to prepare replay output: %v", err)
}
cmd := exec.Command(shellPath)
cmd.Dir = scenario.dir
cmd.Env = recordSessionEnvWithExtra(sandbox, sandboxConfig, scenario.setupScripts, map[string]string{
compareMarkerEnvName: compareMarkerEnabledValue,
})
cmd.Stdin = bytes.NewReader(input)
cmd.Stdout = io.Discard
cmd.Stderr = io.Discard
if err := cmd.Run(); err != nil {
if err := screen.Replay(screen.ReplayRequest{
Cmd: cmd,
Input: input,
OutputLog: rawOutFile,
}); err != nil {
rawOutFile.Close()
return fmt.Errorf("replay failed: %v", err)
}
if err := rawOutFile.Close(); err != nil {
return fmt.Errorf("failed to close replay output: %v", err)
}
got, err := loadRecordedOutput(rawOut)
if err != nil {
internal/mire/test_test.go
+6 -12
View File
@@ -2,6 +2,7 @@ package mire
import (
"bytes"
"os"
"path/filepath"
"strings"
"testing"
@@ -90,17 +91,13 @@ func TestDiscoverTestScenariosRejectsMissingInFixture(t *testing.T) {
}
func TestReplayScenarioUsesRecordedInputAndKeepsReplayOutputQuiet(t *testing.T) {
testutil.AddFakeRecordDependencies(t, "script")
t.Setenv("FAKE_SCRIPT_ECHO_STDIN", "1")
testutil.AddFakeRecordDependencies(t, "bwrap", "bash")
testDir := filepath.Join(t.TempDir(), "e2e")
shellPath := filepath.Join(testDir, "shell.sh")
mustWriteRecordShell(t, testDir)
scenarioDir := filepath.Join(testDir, "suite", "spec")
testutil.WriteScenarioFixtures(t, scenarioDir, "echo replay\nexit\n", "echo replay\nexit\n")
capturedInput := filepath.Join(t.TempDir(), "stdin.capture")
t.Setenv("FAKE_SCRIPT_CAPTURE_STDIN_FILE", capturedInput)
testutil.WriteScenarioFixtures(t, scenarioDir, "echo replay\nexit\n", "echo replay\r\nexit\r\n")
var stdout bytes.Buffer
var stderr bytes.Buffer
@@ -118,9 +115,6 @@ func TestReplayScenarioUsesRecordedInputAndKeepsReplayOutputQuiet(t *testing.T)
t.Fatalf("replayScenario() error = %v", err)
}
if got := testutil.ReadFile(t, capturedInput); got != "echo replay\nexit\n" {
t.Fatalf("captured stdin = %q, want recorded input", got)
}
if stdout.String() != "" {
t.Fatalf("stdout = %q, want empty", stdout.String())
}
@@ -130,12 +124,12 @@ func TestReplayScenarioUsesRecordedInputAndKeepsReplayOutputQuiet(t *testing.T)
}
func TestReplayScenarioFailsWhenCompareMarkerMissing(t *testing.T) {
testutil.AddFakeRecordDependencies(t, "script")
t.Setenv("FAKE_SCRIPT_ECHO_STDIN", "1")
testDir := filepath.Join(t.TempDir(), "e2e")
shellPath := filepath.Join(testDir, "shell.sh")
testutil.WriteFile(t, shellPath, "#!/bin/sh\n")
if err := os.Chmod(shellPath, 0o755); err != nil {
t.Fatalf("Chmod(%q) error = %v", shellPath, err)
}
scenarioDir := filepath.Join(testDir, "suite", "spec")
testutil.WriteScenarioFixtures(t, scenarioDir, "echo replay\nexit\n", "echo replay\nexit\n")
internal/mire/testhelpers_test.go
+68
View File
@@ -5,6 +5,7 @@ import (
"os"
"path/filepath"
"strings"
"sync"
"testing"
"mire/internal/testutil"
@@ -50,6 +51,56 @@ func withRecordStreams[T any](t *testing.T, input string, fn func(recordIO) T) T
})
}
func withPromptedRecordStreams[T any](t *testing.T, sessionInput, promptInput string, fn func(recordIO) T) T {
t.Helper()
reader, writer, err := os.Pipe()
if err != nil {
t.Fatalf("os.Pipe() error = %v", err)
}
t.Cleanup(func() {
_ = reader.Close()
_ = writer.Close()
})
errWriter := &promptSignalBuffer{
marker: "Save recording?",
ready: make(chan struct{}),
}
writeDone := make(chan error, 1)
go func() {
defer close(writeDone)
defer writer.Close()
if _, err := writer.Write([]byte(sessionInput)); err != nil {
writeDone <- err
return
}
<-errWriter.ready
if _, err := writer.Write([]byte(promptInput)); err != nil {
writeDone <- err
return
}
writeDone <- nil
}()
result := fn(recordIO{
in: reader,
out: ioDiscard{},
err: errWriter,
})
if err := <-writeDone; err != nil {
t.Fatalf("write record input: %v", err)
}
return result
}
type ioDiscard struct{}
func (ioDiscard) Write(p []byte) (int, error) {
@@ -90,3 +141,20 @@ func containsEnvKey(env []string, key string) bool {
return false
}
type promptSignalBuffer struct {
bytes.Buffer
marker string
ready chan struct{}
once sync.Once
}
func (b *promptSignalBuffer) Write(p []byte) (int, error) {
n, err := b.Buffer.Write(p)
if strings.Contains(b.Buffer.String(), b.marker) {
b.once.Do(func() {
close(b.ready)
})
}
return n, err
}
internal/screen/screen.go
+336
View File
@@ -0,0 +1,336 @@
package screen
import (
"bytes"
"errors"
"io"
"os"
"os/exec"
"os/signal"
"syscall"
"github.com/creack/pty"
"golang.org/x/sys/unix"
"golang.org/x/term"
)
const (
defaultRows = 24
defaultCols = 80
terminalEOF = byte(0x04)
)
type RecordRequest struct {
Cmd *exec.Cmd
Input io.Reader
Output io.Writer
TTY *os.File
InputLog io.Writer
OutputLog io.Writer
}
type ReplayRequest struct {
Cmd *exec.Cmd
Input []byte
OutputLog io.Writer
}
func Record(req RecordRequest) error {
if req.Cmd == nil {
return errors.New("record session command is required")
}
ptmx, err := pty.StartWithSize(req.Cmd, sessionSize(req.TTY))
if err != nil {
return err
}
defer ptmx.Close()
restoreTTY, err := makeRaw(req.TTY)
if err != nil {
return err
}
defer restoreTTY()
stopResize := watchResize(req.TTY, ptmx)
defer stopResize()
input, closeInput, err := duplicateInput(req.Input)
if err != nil {
return err
}
defer closeInput()
outputDone := copyAsync(combineWriters(req.Output, req.OutputLog), ptmx)
inputDone, stopInput, err := copyInputAsync(combineWriters(ptmx, newInputLogWriter(req.InputLog)), input)
if err != nil {
return err
}
defer stopInput()
waitErr := req.Cmd.Wait()
stopInput()
ptmx.Close()
outputErr := <-outputDone
inputErr := <-inputDone
return firstErr(waitErr, outputErr, inputErr)
}
func Replay(req ReplayRequest) error {
if req.Cmd == nil {
return errors.New("replay session command is required")
}
ptmx, err := pty.StartWithSize(req.Cmd, sessionSize(nil))
if err != nil {
return err
}
defer ptmx.Close()
outputDone := copyAsync(combineWriters(req.OutputLog), ptmx)
inputDone := copyAsync(ptmx, bytes.NewReader(replayInput(req.Input)))
waitErr := req.Cmd.Wait()
ptmx.Close()
outputErr := <-outputDone
inputErr := <-inputDone
return firstErr(waitErr, outputErr, inputErr)
}
func combineWriters(writers ...io.Writer) io.Writer {
active := make([]io.Writer, 0, len(writers))
for _, writer := range writers {
if writer != nil {
active = append(active, writer)
}
}
switch len(active) {
case 0:
return io.Discard
case 1:
return active[0]
default:
return io.MultiWriter(active...)
}
}
func copyAsync(dst io.Writer, src io.Reader) <-chan error {
done := make(chan error, 1)
go func() {
_, err := io.Copy(dst, src)
done <- normalizeCopyError(err)
}()
return done
}
func replayInput(input []byte) []byte {
if len(input) > 0 && input[len(input)-1] == terminalEOF {
return input
}
data := make([]byte, 0, len(input)+1)
data = append(data, input...)
data = append(data, terminalEOF)
return data
}
func copyInputAsync(dst io.Writer, src io.Reader) (<-chan error, func(), error) {
file, ok := src.(*os.File)
if !ok {
done := copyAsync(dst, src)
return done, func() {}, nil
}
stopReader, stopWriter, err := os.Pipe()
if err != nil {
return nil, nil, err
}
done := make(chan error, 1)
go func() {
defer stopReader.Close()
buf := make([]byte, 4096)
fds := []unix.PollFd{
{Fd: int32(file.Fd()), Events: unix.POLLIN | unix.POLLHUP},
{Fd: int32(stopReader.Fd()), Events: unix.POLLIN | unix.POLLHUP},
}
for {
_, err := unix.Poll(fds, -1)
if err != nil {
if err == unix.EINTR {
continue
}
done <- err
return
}
if fds[1].Revents != 0 {
done <- nil
return
}
if fds[0].Revents&(unix.POLLIN|unix.POLLHUP) == 0 {
continue
}
n, readErr := file.Read(buf)
if n > 0 {
if _, writeErr := dst.Write(buf[:n]); writeErr != nil {
done <- normalizeCopyError(writeErr)
return
}
}
if readErr != nil {
done <- normalizeCopyError(readErr)
return
}
}
}()
stop := func() {
_ = stopWriter.Close()
_ = file.Close()
}
return done, stop, nil
}
func normalizeCopyError(err error) error {
switch {
case err == nil:
return nil
case errors.Is(err, io.EOF):
return nil
case errors.Is(err, os.ErrClosed):
return nil
case errors.Is(err, syscall.EIO):
return nil
default:
return err
}
}
func firstErr(errs ...error) error {
for _, err := range errs {
if err != nil {
return err
}
}
return nil
}
func sessionSize(tty *os.File) *pty.Winsize {
if tty != nil && term.IsTerminal(int(tty.Fd())) {
if cols, rows, err := term.GetSize(int(tty.Fd())); err == nil {
return &pty.Winsize{
Rows: uint16(rows),
Cols: uint16(cols),
}
}
}
return &pty.Winsize{
Rows: defaultRows,
Cols: defaultCols,
}
}
func makeRaw(tty *os.File) (func(), error) {
if tty == nil || !term.IsTerminal(int(tty.Fd())) {
return func() {}, nil
}
state, err := term.MakeRaw(int(tty.Fd()))
if err != nil {
return nil, err
}
return func() {
_ = term.Restore(int(tty.Fd()), state)
}, nil
}
func watchResize(tty *os.File, ptmx *os.File) func() {
if tty == nil || !term.IsTerminal(int(tty.Fd())) {
return func() {}
}
applySize := func() {
_ = pty.Setsize(ptmx, sessionSize(tty))
}
applySize()
signals := make(chan os.Signal, 1)
signal.Notify(signals, syscall.SIGWINCH)
done := make(chan struct{})
go func() {
for {
select {
case <-signals:
applySize()
case <-done:
return
}
}
}()
return func() {
signal.Stop(signals)
close(done)
}
}
func duplicateInput(input io.Reader) (io.Reader, func(), error) {
if input == nil {
return bytes.NewReader(nil), func() {}, nil
}
file, ok := input.(*os.File)
if !ok {
return input, func() {}, nil
}
fd, err := syscall.Dup(int(file.Fd()))
if err != nil {
return nil, nil, err
}
dup := os.NewFile(uintptr(fd), file.Name())
return dup, func() {
_ = dup.Close()
}, nil
}
type inputLogWriter struct {
dst io.Writer
}
func newInputLogWriter(dst io.Writer) io.Writer {
if dst == nil {
return io.Discard
}
return inputLogWriter{dst: dst}
}
func (w inputLogWriter) Write(p []byte) (int, error) {
normalized := make([]byte, len(p))
for i, b := range p {
if b == '\r' {
normalized[i] = '\n'
continue
}
normalized[i] = b
}
if _, err := w.dst.Write(normalized); err != nil {
return 0, err
}
return len(p), nil
}
internal/screen/screen_test.go
+66
View File
@@ -0,0 +1,66 @@
package screen
import (
"bytes"
"os"
"os/exec"
"testing"
)
func TestRecordCopiesInputAndOutput(t *testing.T) {
reader, writer, err := os.Pipe()
if err != nil {
t.Fatalf("os.Pipe() error = %v", err)
}
t.Cleanup(func() {
_ = reader.Close()
_ = writer.Close()
})
go func() {
_, _ = writer.Write([]byte("hello\n"))
_ = writer.Close()
}()
cmd := exec.Command("sh", "-c", `printf 'ready\n'; read line; printf 'line:%s\n' "$line"`)
var live bytes.Buffer
var inputLog bytes.Buffer
var outputLog bytes.Buffer
if err := Record(RecordRequest{
Cmd: cmd,
Input: reader,
Output: &live,
InputLog: &inputLog,
OutputLog: &outputLog,
}); err != nil {
t.Fatalf("Record() error = %v", err)
}
if got := inputLog.String(); got != "hello\n" {
t.Fatalf("input log = %q, want %q", got, "hello\n")
}
for _, got := range []string{live.String(), outputLog.String()} {
if !bytes.Contains([]byte(got), []byte("ready")) || !bytes.Contains([]byte(got), []byte("line:hello")) {
t.Fatalf("output = %q, want ready + line:hello", got)
}
}
}
func TestReplayCapturesOutput(t *testing.T) {
cmd := exec.Command("sh", "-c", `read line; printf '__MIRE_E2E_BEGIN__\nline:%s\n' "$line"`)
var outputLog bytes.Buffer
if err := Replay(ReplayRequest{
Cmd: cmd,
Input: []byte("hello\n"),
OutputLog: &outputLog,
}); err != nil {
t.Fatalf("Replay() error = %v", err)
}
got := outputLog.String()
if !bytes.Contains([]byte(got), []byte("__MIRE_E2E_BEGIN__")) || !bytes.Contains([]byte(got), []byte("line:hello")) {
t.Fatalf("output log = %q, want marker + line:hello", got)
}
}
internal/testutil/testutil.go
+170 -1
View File
@@ -6,6 +6,8 @@ import (
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"testing"
)
@@ -53,6 +55,113 @@ func CaptureOutput(t *testing.T, fn func()) (string, string) {
return stdoutBuf.String(), stderrBuf.String()
}
func CapturePromptedOutput(t *testing.T, sessionInput, promptMarker, promptInput string, fn func()) (string, string) {
t.Helper()
t.Setenv("NO_COLOR", "1")
stdinReader, stdinWriter, err := os.Pipe()
if err != nil {
t.Fatalf("os.Pipe() stdin error = %v", err)
}
stdoutReader, stdoutWriter, err := os.Pipe()
if err != nil {
t.Fatalf("os.Pipe() stdout error = %v", err)
}
stderrReader, stderrWriter, err := os.Pipe()
if err != nil {
t.Fatalf("os.Pipe() stderr error = %v", err)
}
oldStdin := os.Stdin
oldStdout := os.Stdout
oldStderr := os.Stderr
os.Stdin = stdinReader
os.Stdout = stdoutWriter
os.Stderr = stderrWriter
t.Cleanup(func() {
os.Stdin = oldStdin
os.Stdout = oldStdout
os.Stderr = oldStderr
})
var stdinOnce sync.Once
closeStdin := func() {
stdinOnce.Do(func() {
_ = stdinWriter.Close()
})
}
t.Cleanup(closeStdin)
var stdoutBuf bytes.Buffer
stdoutDone := make(chan error, 1)
go func() {
_, err := io.Copy(&stdoutBuf, stdoutReader)
stdoutDone <- err
}()
var stderrBuf bytes.Buffer
var promptOnce sync.Once
stderrDone := make(chan error, 1)
go func() {
buf := make([]byte, 1024)
for {
n, readErr := stderrReader.Read(buf)
if n > 0 {
if _, err := stderrBuf.Write(buf[:n]); err != nil {
stderrDone <- err
return
}
if promptMarker != "" && strings.Contains(stderrBuf.String(), promptMarker) {
promptOnce.Do(func() {
if _, err := stdinWriter.Write([]byte(promptInput)); err != nil {
stderrDone <- err
return
}
closeStdin()
})
}
}
if readErr == nil {
continue
}
if readErr == io.EOF {
stderrDone <- nil
return
}
stderrDone <- readErr
return
}
}()
go func() {
if _, err := stdinWriter.Write([]byte(sessionInput)); err != nil {
return
}
if promptMarker == "" {
closeStdin()
}
}()
fn()
closeStdin()
if err := stdoutWriter.Close(); err != nil {
t.Fatalf("stdout close error = %v", err)
}
if err := stderrWriter.Close(); err != nil {
t.Fatalf("stderr close error = %v", err)
}
if err := <-stdoutDone; err != nil {
t.Fatalf("stdout copy error = %v", err)
}
if err := <-stderrDone; err != nil {
t.Fatalf("stderr copy error = %v", err)
}
return stdoutBuf.String(), stderrBuf.String()
}
func WriteFile(t *testing.T, path, content string) {
t.Helper()
@@ -233,6 +342,61 @@ if [ -n "${FAKE_SCRIPT_EXIT_CODE:-}" ]; then
exit "$FAKE_SCRIPT_EXIT_CODE"
fi
exit 0
`
}
if name == "bwrap" {
body = `#!/bin/sh
while [ "$#" -gt 0 ]; do
case "$1" in
--ro-bind|--bind|--setenv)
shift 3
;;
--tmpfs|--chdir)
shift 2
;;
--dev|--proc)
shift 2
;;
--unshare-pid|--die-with-parent)
shift
;;
*)
break
;;
esac
done
if [ "$#" -eq 0 ]; then
exit 0
fi
exec "$@"
`
}
if name == "bash" {
body = `#!/bin/sh
while [ "$#" -gt 0 ]; do
case "$1" in
--noprofile|--norc|-i)
shift
;;
--rcfile)
shift 2
;;
*)
shift
;;
esac
done
/bin/stty -echo 2>/dev/null || true
while IFS= read -r line || [ -n "$line" ]; do
printf '%s\n' "$line"
if [ "$line" = "exit" ]; then
break
fi
done
exit 0
`
}
if err := os.WriteFile(path, []byte(body), 0o755); err != nil {
@@ -240,7 +404,12 @@ exit 0
}
}
t.Setenv("PATH", binDir)
oldPath := os.Getenv("PATH")
if oldPath == "" {
t.Setenv("PATH", binDir)
return
}
t.Setenv("PATH", binDir+string(os.PathListSeparator)+oldPath)
}
func RequireCommands(t *testing.T, names ...string) {