agenttest

func CodexAppServer ¶

func CodexAppServer(t *testing.T, script CodexAppServerScript) (bin, record string)

CodexAppServer arranges for the running test binary, re-executed, to be a fake `codex app-server` scripted by script, the way FAKE_CLAUDE and Runner.ClaudeBin = os.Args[0] do for claude in a caller's tests (see CONTRIBUTING.md): it sets CodexAppServerFakeEnv and the script's location for the rest of the calling test (t.Setenv, undone when it ends) and returns the test binary's own path, which the caller hands a Runner as CodexBin, or runs directly. Invoked with "app-server" as its first argument, the fake speaks the app-server JSON-RPC conversation over stdin and stdout, one message per line, and exits when stdin closes. Invoked with "mcp" as its first argument instead — a restricted turn's inventory, run apart from the app-server process — it prints script's MCPServers (or MCPServersRaw) and exits at once, reading nothing. Every line the app-server conversation receives, and every invocation's own argv, go to the record file whose path CodexAppServer also returns, which ReadCodexAppServerRecord reads back; it also counts how many times the fake started.

A test binary that wants to offer this fake must check CodexAppServerFakeEnv in its own TestMain and call RunCodexAppServer when it is set, as this package's own tests do; CodexAppServer only arranges the environment, since it has no way to install a TestMain in the caller's package.

func Docker ¶

func Docker(t *testing.T, image, sessionVariable string) string

Docker writes a fake container engine. It answers `network`, `rm`, `image` and `build`, and runs what `run` is given on this machine, recording its arguments and environment in the directory sessionVariable names. A `run` with --entrypoint is the look an agent.NewContainer session takes into its image before any turn: its arguments are recorded in docker-probe.txt beside the script, and it prints image-vcs.txt from there, the VCS executables the image is to have ("f <path>" or "d <path>" a line; none without the file), or fails when a file named fail-probe is there.

Every subcommand but `run` and the probe is answered without consulting a real Docker: `network` always reports the one fixed gateway address, and `rm` always succeeds, whatever arguments they were given. A test that needs those to fail, or that needs the gateway address to vary, must use its own script instead. `run` itself is the one call this fake does not fake: it execs the command the caller gave it for real, after recording the arguments and environment it was started with.

func MCPServer ¶

func MCPServer(t *testing.T, sessionVariable string) string

MCPServer writes a fake host MCP server: it records its environment, PID and arguments beside sessionVariable names, prints one fixed listening address and then idles. It always starts and never reports a port already in use or any other startup failure; a test of that behaviour must use a script of its own.

func RunCodexAppServer ¶

func RunCodexAppServer() int

RunCodexAppServer runs a fake `codex app-server` on stdin and stdout, scripted by the CodexAppServerScript that CodexAppServer wrote under the directory named by codexAppServerDirEnv, appending its own argv and every line it receives there (record.jsonl). It returns the process's exit code: always 0, short of being unable to read back its own script or open its record file.

func Sbx ¶

func Sbx(t *testing.T, sessionVariable string) string

Sbx writes a fake Docker Sandboxes CLI. `create` records its arguments in sbx-create.txt beside the script and fails when a file named fail-create is there, fails as sbx's start does after it has made the sandbox (a bare HTTP 500) when one named fail-start is, and fails the way sbx does when its primary workspace, the first one, is read-only, is not a directory, or has a parent at or inside a read-only workspace, where sbx's start writes the agent's instructions; `exec --interactive`, the session's command, records its arguments and the client's environment in the directory sessionVariable names (sbx-exec-args.txt, sbx-exec-env.txt) and runs the command after the sandbox name on this machine; `exec --workdir`, a probe the runner runs before the session's command, appends its arguments to sbx-probe.txt beside the script and runs its command the same way; `exec <name> dagger version` appends its arguments to sbx-dagger-probe.txt beside the script, one call per line, and prints the release in a file named dagger-version there the way `dagger version` does, or fails as a missing CLI when there is none; any other `exec`, a setup command, is appended to sbx-setup.txt beside the script, one argument per line, runs nothing and fails when a file named fail-setup is there; `policy` appends its arguments to sbx-policy.txt beside the script, one call per line, and fails when a file named fail-policy is there, `policy rm` also when one named fail-policy-rm is; `rm` records its arguments in sbx-rm.txt beside the script; `version` prints one, and fails when a file named fail-version is there. Every call but `exec` and `version` also appends its first two arguments to sbx-calls.txt beside the script, in the order they ran.

`rm` and `policy` beside `policy rm` always succeed unless their marker file is there: the fake does not check that a name passed to `rm` or a rule passed to `policy` matches a sandbox or rule that actually exists. A test of that check must read the recorded arguments itself.

func Script ¶

func Script(t *testing.T, name, body string) string

Script writes a fake executable under the test's temporary directory.