@automattic/vip 4.1.5 → 4.1.6

package/internal/devenv/devexec_test.go

@@ -1,91 +0,0 @@
-package devenv
-
-import (
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/dockercli"
-)
-
-func pinnedRunner() *dockercli.Runner {
-	r := &dockercli.Runner{}
-	r.SetComposeCmdForTest([]string{"docker", "compose"})
-	return r
-}
-
-func TestExecArgv(t *testing.T) {
-	r := pinnedRunner()
-	got := execArgv(r, "myslug", []string{"post", "list", "--format=json"}, false)
-	want := []string{"docker", "compose", "-p", "myslug", "exec", "php", "wp", "--allow-root", "post", "list", "--format=json"}
-	assertArgv(t, got, want)
-}
-
-// TestExecArgvNoTTY: when stdin is not a terminal (piped output), -T is inserted
-// to disable docker compose's default pseudo-TTY allocation.
-func TestExecArgvNoTTY(t *testing.T) {
-	r := pinnedRunner()
-	got := execArgv(r, "myslug", []string{"post", "list"}, true)
-	want := []string{"docker", "compose", "-p", "myslug", "exec", "-T", "php", "wp", "--allow-root", "post", "list"}
-	assertArgv(t, got, want)
-}
-
-func TestShellArgvDefaultPHP(t *testing.T) {
-	r := pinnedRunner()
-	got := shellArgv(r, "s", "php", false, nil, false)
-	// No command + interactive (TTY): prefer bash with -i (Node landoShell parity),
-	// fall back to sh for containers without bash.
-	want := []string{"docker", "compose", "-p", "s", "exec", "-u", "www-data", "php",
-		"/bin/sh", "-c", "if [ -x /bin/bash ]; then /bin/bash -i; else /bin/sh -i; fi; exit 0"}
-	assertArgv(t, got, want)
-}
-
-// TestShellArgvDefaultNonInteractive: no command + piped stdin drops the -i flag
-// (matches Node's stdin.isTTY gate) and adds -T.
-func TestShellArgvDefaultNonInteractive(t *testing.T) {
-	r := pinnedRunner()
-	got := shellArgv(r, "s", "php", false, nil, true)
-	want := []string{"docker", "compose", "-p", "s", "exec", "-T", "-u", "www-data", "php",
-		"/bin/sh", "-c", "if [ -x /bin/bash ]; then /bin/bash; else /bin/sh; fi; exit 0"}
-	assertArgv(t, got, want)
-}
-
-func TestShellArgvRootWithCmd(t *testing.T) {
-	r := pinnedRunner()
-	got := shellArgv(r, "s", "database", true, []string{"ls", "-lha"}, false)
-	want := []string{"docker", "compose", "-p", "s", "exec", "-u", "root", "database", "ls", "-lha"}
-	assertArgv(t, got, want)
-}
-
-// TestShellArgvNoTTY: -T precedes the -u/service options when non-interactive.
-func TestShellArgvNoTTY(t *testing.T) {
-	r := pinnedRunner()
-	got := shellArgv(r, "s", "database", false, []string{"ls"}, true)
-	want := []string{"docker", "compose", "-p", "s", "exec", "-T", "-u", "mysql", "database", "ls"}
-	assertArgv(t, got, want)
-}
-
-func TestShellUserMapping(t *testing.T) {
-	if shellUser("php", false) != "www-data" {
-		t.Fatal("php non-root should map to www-data")
-	}
-	if shellUser("database", false) != "mysql" {
-		t.Fatal("database non-root should map to mysql")
-	}
-	if shellUser("php", true) != "root" {
-		t.Fatal("root flag should force root")
-	}
-	if shellUser("unknown-svc", false) != "www-data" {
-		t.Fatal("unknown service should default to www-data")
-	}
-}
-
-func assertArgv(t *testing.T, got, want []string) {
-	t.Helper()
-	if len(got) != len(want) {
-		t.Fatalf("argv = %v, want %v", got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Fatalf("argv[%d] = %q, want %q (full %v)", i, got[i], want[i], got)
-		}
-	}
-}

package/internal/devenv/devlog/devlog.go

@@ -1,219 +0,0 @@
-// Package devlog owns the per-environment dev-env command log. Every
-// docker/docker compose invocation tees its output here via Writer(), and the
-// CLI's own dev-env diagnostics are logged through Logf, so VIP and Docker
-// output interleave in one per-invocation timestamped file — the behavior
-// Lando's winston logger + shell tee provided before. Each invocation opens a
-// fresh file under the environment's own logs/ directory (Node parity:
-// getDevEnvLogFile -> vip-dev-env-<slug>-<timestamp>.log).
-package devlog
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-const logName = "vip-dev-env"
-
-// Logger is a single open handle to one invocation's log file. Safe for
-// concurrent writers (the tee from stdout and stderr run concurrently).
-type Logger struct {
-	mu   sync.Mutex
-	f    *os.File
-	path string
-	tty  io.Writer // where Finish() prints the log-path footer
-}
-
-// Open creates the environment's logs/ directory and opens a fresh,
-// per-invocation timestamped log file for appending.
-func Open(slug string) (*Logger, error) {
-	dir := paths.EnvLogDir(slug)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return nil, err
-	}
-	p := filepath.Join(dir, logFileName(slug, time.Now()))
-	f, err := os.OpenFile(p, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
-	if err != nil {
-		return nil, err
-	}
-	return &Logger{f: f, path: p, tty: os.Stderr}, nil
-}
-
-// logFileName builds vip-dev-env-<slug>-<timestamp>.log, matching Node's
-// getDevEnvLogFile (formatDevEnvLogSlug + formatDevEnvLogTimestamp).
-func logFileName(slug string, t time.Time) string {
-	return fmt.Sprintf("%s-%s-%s.log", logName, formatLogSlug(slug), t.UTC().Format("20060102-150405"))
-}
-
-var logSlugInvalid = regexp.MustCompile(`[^a-z0-9_-]+`)
-
-// formatLogSlug mirrors Node's formatDevEnvLogSlug: lowercase, replacing any
-// run of disallowed characters with a single dash. An empty slug maps to "all".
-func formatLogSlug(slug string) string {
-	if slug == "" {
-		return "all"
-	}
-	return logSlugInvalid.ReplaceAllString(strings.ToLower(slug), "-")
-}
-
-// Path returns the log file path.
-func (l *Logger) Path() string { return l.path }
-
-// Close closes the underlying file.
-func (l *Logger) Close() error {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	return l.f.Close()
-}
-
-// writeLine writes one prefixed line (no trailing newline in msg).
-func (l *Logger) writeLine(level, msg string) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	ts := time.Now().UTC().Format("2006-01-02T15:04:05Z")
-	_, _ = fmt.Fprintf(l.f, "%s [%s] %s: %s\n", ts, logName, level, msg)
-}
-
-// Logf writes a single diagnostic line at INFO level.
-func (l *Logger) Logf(format string, args ...any) {
-	l.writeLine("INFO", fmt.Sprintf(format, args...))
-}
-
-// Writer returns an io.WriteCloser that splits input into lines and writes
-// each complete line to the log with a prefix. A trailing partial line is
-// held in a buffer and flushed when the writer is Closed — callers MUST
-// Close the writer (after the subprocess exits) so a final non-newline-
-// terminated line is not lost.
-//
-// Each returned writer is single-goroutine: its internal line buffer is not
-// synchronized, so call Writer() once per concurrent stream (e.g. separate
-// writers for a subprocess's stdout and stderr) rather than sharing one
-// writer across goroutines. Writes to the underlying log file are serialized.
-func (l *Logger) Writer() io.WriteCloser {
-	return &lineWriter{log: l, level: "INFO"}
-}
-
-// DockerVersions holds the docker/compose versions shown in the banner.
-type DockerVersions struct {
-	Engine, Compose, ComposePlugin, DockerBin, ComposeBin string
-}
-
-// Banner is the diagnostic header written once at the top of a fresh log.
-// Ports writeLogBanner (dev-environment-lando.ts:247-286); NODE is replaced
-// by CLI/runtime since there is no Node runtime any more.
-type Banner struct {
-	Command string
-	OS      string
-	CLI     string
-	Runtime string
-	Docker  DockerVersions
-	RAMGB   string
-	CPUs    string
-}
-
-// WriteBanner appends the banner only if the log file is currently empty,
-// matching Lando's "write banner when size == 0" behavior.
-func (l *Logger) WriteBanner(b Banner) error {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	info, err := l.f.Stat()
-	if err != nil {
-		return err
-	}
-	if info.Size() > 0 {
-		return nil
-	}
-
-	line := func(label, value string) string {
-		return fmt.Sprintf("%-18s %s\n", label, value)
-	}
-	var sb []byte
-	sb = append(sb, "=== VIP Dev Env Log ===\n"...)
-	sb = append(sb, line("COMMAND", b.Command)...)
-	sb = append(sb, line("OS", b.OS)...)
-	sb = append(sb, line("CLI", b.CLI)...)
-	sb = append(sb, line("RUNTIME", b.Runtime)...)
-	sb = append(sb, line("DOCKER ENGINE", b.Docker.Engine)...)
-	sb = append(sb, line("DOCKER COMPOSE", b.Docker.Compose)...)
-	sb = append(sb, line("COMPOSE PLUGIN", b.Docker.ComposePlugin)...)
-	sb = append(sb, line("DOCKER BIN", b.Docker.DockerBin)...)
-	sb = append(sb, line("COMPOSE BIN", b.Docker.ComposeBin)...)
-	sb = append(sb, line("RAM", b.RAMGB)...)
-	sb = append(sb, line("CPU", b.CPUs)...)
-	sb = append(sb, "===\n\n\n"...)
-
-	_, err = l.f.Write(sb)
-	return err
-}
-
-type lineWriter struct {
-	log   *Logger
-	level string
-	buf   bytes.Buffer
-}
-
-func (w *lineWriter) Write(p []byte) (int, error) {
-	w.buf.Write(p)
-	for {
-		line, err := w.buf.ReadString('\n')
-		if err != nil {
-			// No newline yet: put the partial back and wait for more.
-			w.buf.Reset()
-			w.buf.WriteString(line)
-			break
-		}
-		w.log.writeLine(w.level, strings.TrimRight(line[:len(line)-1], "\r"))
-	}
-	return len(p), nil
-}
-
-// Close flushes any buffered partial (non-newline-terminated) line to the
-// log so trailing output is never dropped.
-func (w *lineWriter) Close() error {
-	if w.buf.Len() > 0 {
-		w.log.writeLine(w.level, w.buf.String())
-		w.buf.Reset()
-	}
-	return nil
-}
-
-// SetFooterWriter overrides where Finish() writes (defaults to stderr).
-// Used in tests; production passes os.Stderr.
-func (l *Logger) SetFooterWriter(w io.Writer) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	l.tty = w
-}
-
-// Finish prints the "COMMAND LOG FILE <path>" footer so users can find the
-// combined log. Ports registerLogPathOutput (dev-environment-lando.ts:146-171).
-func (l *Logger) Finish() {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	fmt.Fprintf(l.tty, "\n %-18s %s\n", "COMMAND LOG FILE", l.path)
-}
-
-// loggerCtxKey is the private context key under which a session Logger is
-// carried so the docker runner can pick it up without signature churn.
-type loggerCtxKey struct{}
-
-// WithLogger returns a context carrying l, so newRunner can tee through it.
-func WithLogger(ctx context.Context, l *Logger) context.Context {
-	return context.WithValue(ctx, loggerCtxKey{}, l)
-}
-
-// FromContext returns the session Logger carried by ctx, or nil.
-func FromContext(ctx context.Context) *Logger {
-	l, _ := ctx.Value(loggerCtxKey{}).(*Logger)
-	return l
-}

package/internal/devenv/devlog/devlog_test.go

@@ -1,112 +0,0 @@
-package devlog
-
-import (
-	"bytes"
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestWriterFlushesPartialLineOnClose(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	l, err := Open("testslug")
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	w := l.Writer()
-	w.Write([]byte("no newline at end"))
-	if err := w.Close(); err != nil {
-		t.Fatalf("Writer Close: %v", err)
-	}
-	if err := l.Close(); err != nil {
-		t.Fatalf("Close: %v", err)
-	}
-	b, err := os.ReadFile(l.Path())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(b), "no newline at end") {
-		t.Fatalf("partial line lost; log:\n%s", b)
-	}
-}
-
-func TestWriterPrefixesCompleteLinesIntoLogFile(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-
-	l, err := Open("testslug")
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	w := l.Writer()
-	// Two writes that together form exactly two complete lines split across
-	// the write boundary ("hello\n" and "world\n"). No partial remains.
-	w.Write([]byte("hello\nwor"))
-	w.Write([]byte("ld\n"))
-	if err := l.Close(); err != nil {
-		t.Fatalf("Close: %v", err)
-	}
-
-	b, err := os.ReadFile(l.Path())
-	if err != nil {
-		t.Fatal(err)
-	}
-	got := string(b)
-	if c := strings.Count(got, "[vip-dev-env] INFO:"); c != 2 {
-		t.Fatalf("expected 2 prefixed lines, got %d in:\n%s", c, got)
-	}
-	if !strings.Contains(got, "hello") || !strings.Contains(got, "world") {
-		t.Fatalf("log missing content:\n%s", got)
-	}
-}
-
-func TestWriteBannerOnlyOnEmptyLog(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-
-	b := Banner{
-		Command: "vip dev-env start",
-		OS:      "darwin 25.5.0 arm64",
-		CLI:     "4.0.0",
-		Runtime: "go",
-		Docker:  DockerVersions{Engine: "27.0", Compose: "2.29", ComposePlugin: "2.29", DockerBin: "/usr/bin/docker", ComposeBin: "docker compose"},
-		RAMGB:   "16.0 GB",
-		CPUs:    "10",
-	}
-
-	l, _ := Open("testslug")
-	if err := l.WriteBanner(b); err != nil {
-		t.Fatalf("WriteBanner: %v", err)
-	}
-	// Second call must be a no-op because the file is no longer empty.
-	if err := l.WriteBanner(b); err != nil {
-		t.Fatalf("WriteBanner (2nd): %v", err)
-	}
-	l.Close()
-
-	data, _ := os.ReadFile(l.Path())
-	got := string(data)
-	if c := strings.Count(got, "=== VIP Dev Env Log ==="); c != 1 {
-		t.Fatalf("banner written %d times, want 1:\n%s", c, got)
-	}
-	for _, want := range []string{"COMMAND", "DOCKER ENGINE", "27.0", "vip dev-env start"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("banner missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestFinishPrintsLogPathFooter(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	l, _ := Open("testslug")
-
-	var tty bytes.Buffer
-	l.SetFooterWriter(&tty)
-	l.Finish()
-	l.Close()
-
-	if !strings.Contains(tty.String(), "COMMAND LOG FILE") {
-		t.Fatalf("footer missing label: %q", tty.String())
-	}
-	if !strings.Contains(tty.String(), l.Path()) {
-		t.Fatalf("footer missing path %q in %q", l.Path(), tty.String())
-	}
-}

package/internal/devenv/devterm/devterm.go

@@ -1,65 +0,0 @@
-// Package devterm runs an interactive child process attached to a PTY and tees
-// the PTY master to both the terminal and the unified dev-env log (spec §7.3).
-// It is the §C "sharp edge" isolated here and reused by exec + shell.
-//
-// This file holds the cross-platform core: argv handling, the TTY check
-// (Interactive), and the non-interactive RunPiped path (plain pipes, no PTY).
-// The interactive raw-mode PTY run lives in devterm_pty.go (built on every
-// non-Windows platform); Windows gets devterm_stub.go because that path needs
-// Unix-only primitives (creack/pty, SIGWINCH, raw-mode termios).
-package devterm
-
-import (
-	"context"
-	"errors"
-	"io"
-	"os"
-	"os/exec"
-
-	"golang.org/x/term"
-)
-
-// splitArgv splits a non-empty argv into the binary name and its arguments.
-func splitArgv(argv []string) (string, []string) {
-	return argv[0], argv[1:]
-}
-
-// safeSplit is splitArgv with an empty-argv guard, used by Run.
-func safeSplit(argv []string) (string, []string, error) {
-	if len(argv) == 0 {
-		return "", nil, errors.New("devterm: empty argv")
-	}
-	name, rest := splitArgv(argv)
-	return name, rest, nil
-}
-
-// Interactive reports whether stdin is a terminal. Callers use it to choose
-// between the raw-mode PTY path (Run) and the plain-pipe path (RunPiped), and
-// to decide whether to disable docker compose's default TTY allocation. This
-// mirrors Node's dev-env, which gates interactivity on process.stdin.isTTY
-// (vip-dev-env-shell.js / dev-environment-lando.ts landoShell).
-func Interactive() bool {
-	return term.IsTerminal(int(os.Stdin.Fd()))
-}
-
-// RunPiped runs argv with inherited stdin and the caller-provided stdout/stderr
-// writers (which devexec wires to MultiWriter(os.Stdout, log) and
-// MultiWriter(os.Stderr, log) so output both reaches the terminal and tees to
-// the unified dev-env log). Unlike Run it allocates no PTY and touches no raw
-// terminal state, so it works when stdout/stdin are pipes (e.g.
-// `vip dev-env exec -- wp post list --format=json > out.json`) and on every
-// platform, Windows included. When dir is non-empty the child runs there.
-func RunPiped(ctx context.Context, dir string, argv []string, stdout, stderr io.Writer) error {
-	name, rest, err := safeSplit(argv)
-	if err != nil {
-		return err
-	}
-	cmd := exec.CommandContext(ctx, name, rest...)
-	if dir != "" {
-		cmd.Dir = dir
-	}
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = stdout
-	cmd.Stderr = stderr
-	return cmd.Run()
-}

package/internal/devenv/devterm/devterm_pty.go

@@ -1,58 +0,0 @@
-//go:build !windows
-
-package devterm
-
-import (
-	"context"
-	"io"
-	"os"
-	"os/exec"
-	"os/signal"
-	"syscall"
-
-	"github.com/creack/pty"
-	"golang.org/x/term"
-)
-
-// Run starts argv attached to a PTY, puts the host terminal in raw mode, copies
-// stdin->pty and pty->MultiWriter(os.Stdout, logW), handles SIGWINCH, and
-// restores the terminal on exit. The unified-log tee falls out of the
-// MultiWriter. When dir is non-empty the child runs with that working directory
-// (the env's materialized dir so `docker compose exec` finds its compose file).
-// Built on every non-Windows platform; needs a controlling TTY at runtime
-// (term.MakeRaw errors cleanly if stdin is not a terminal).
-func Run(ctx context.Context, dir string, argv []string, logW io.Writer) error {
-	name, rest, err := safeSplit(argv)
-	if err != nil {
-		return err
-	}
-	cmd := exec.CommandContext(ctx, name, rest...)
-	if dir != "" {
-		cmd.Dir = dir
-	}
-	ptmx, err := pty.Start(cmd)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = ptmx.Close() }()
-
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, syscall.SIGWINCH)
-	go func() {
-		for range ch {
-			_ = pty.InheritSize(os.Stdin, ptmx)
-		}
-	}()
-	ch <- syscall.SIGWINCH // initial sizing
-	defer signal.Stop(ch)
-
-	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
-	if err != nil {
-		return err
-	}
-	defer func() { _ = term.Restore(int(os.Stdin.Fd()), oldState) }()
-
-	go func() { _, _ = io.Copy(ptmx, os.Stdin) }()
-	_, _ = io.Copy(io.MultiWriter(os.Stdout, logW), ptmx)
-	return cmd.Wait()
-}

package/internal/devenv/devterm/devterm_stub.go

@@ -1,20 +0,0 @@
-//go:build windows
-
-package devterm
-
-import (
-	"context"
-	"errors"
-	"io"
-)
-
-// Run (stub) — the real raw-mode PTY implementation lives in devterm_pty.go and
-// is built on every non-Windows platform. Windows is excluded because the PTY
-// path depends on Unix-only primitives (creack/pty, SIGWINCH, raw-mode termios),
-// so it returns a clear unsupported error here.
-func Run(_ context.Context, _ string, argv []string, _ io.Writer) error {
-	if _, _, err := safeSplit(argv); err != nil {
-		return err
-	}
-	return errors.New("devterm: interactive exec/shell is not supported on Windows")
-}

package/internal/devenv/devterm/devterm_test.go

@@ -1,78 +0,0 @@
-package devterm
-
-import (
-	"bytes"
-	"context"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-// TestRunPipedTeesStdout runs a harmless command and verifies stdout is written
-// to the caller-provided stdout writer (devexec wires this to MultiWriter(os.Stdout, log)).
-func TestRunPipedTeesStdout(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("requires a POSIX shell (echo/sh)")
-	}
-	var out, errb bytes.Buffer
-	if err := RunPiped(context.Background(), "", []string{"echo", "hello-piped"}, &out, &errb); err != nil {
-		t.Fatalf("RunPiped: %v", err)
-	}
-	if got := strings.TrimSpace(out.String()); got != "hello-piped" {
-		t.Fatalf("stdout = %q, want hello-piped", got)
-	}
-}
-
-// TestRunPipedTeesStderr verifies stderr goes to the stderr writer, not stdout.
-func TestRunPipedTeesStderr(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("requires a POSIX shell (echo/sh)")
-	}
-	var out, errb bytes.Buffer
-	if err := RunPiped(context.Background(), "", []string{"sh", "-c", "echo oops 1>&2"}, &out, &errb); err != nil {
-		t.Fatalf("RunPiped: %v", err)
-	}
-	if out.Len() != 0 {
-		t.Fatalf("stdout = %q, want empty", out.String())
-	}
-	if got := strings.TrimSpace(errb.String()); got != "oops" {
-		t.Fatalf("stderr = %q, want oops", got)
-	}
-}
-
-// TestRunPipedPropagatesExit verifies a non-zero child exit surfaces as an error
-// (so the CLI can set a non-zero exit code, like Node's process.exitCode = 1).
-func TestRunPipedPropagatesExit(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("requires a POSIX shell (sh)")
-	}
-	var out, errb bytes.Buffer
-	if err := RunPiped(context.Background(), "", []string{"sh", "-c", "exit 3"}, &out, &errb); err == nil {
-		t.Fatal("expected error for non-zero exit")
-	}
-}
-
-// TestRunPipedEmptyArgv guards the empty-argv path.
-func TestRunPipedEmptyArgv(t *testing.T) {
-	var out, errb bytes.Buffer
-	if err := RunPiped(context.Background(), "", nil, &out, &errb); err == nil {
-		t.Fatal("expected error for empty argv")
-	}
-}
-
-func TestSplitArgvForExec(t *testing.T) {
-	argv := []string{"docker", "compose", "-p", "x", "exec", "php", "sh"}
-	name, rest := splitArgv(argv)
-	if name != "docker" {
-		t.Fatalf("name = %q, want docker", name)
-	}
-	if len(rest) != 6 || rest[0] != "compose" || rest[5] != "sh" {
-		t.Fatalf("rest = %v", rest)
-	}
-}
-
-func TestSplitArgvEmpty(t *testing.T) {
-	if _, _, err := safeSplit(nil); err == nil {
-		t.Fatal("expected error for empty argv")
-	}
-}