792 lines
35 KiB
Python
792 lines
35 KiB
Python
"""覆盖率 78%->85% 第 2 步：host.py 剩余缺口的真实行为测试。
|
||
|
||
分三类，全部用临时目录/临时 git 仓库，不跑真实模型：
|
||
- 纯函数：merge_task（成功 / 验测回滚 / -X ours 自动解成功与丢改动
|
||
回滚）、run_health_check、notify_failure；
|
||
- stub Server：dispatch / dispatch_from_branch / run_task_turn /
|
||
run_task_turn_with_retry / run_goal_loop（goal-met / unmet /
|
||
预算中断 / 回合异常）；
|
||
- main() 进程内调用（--config/--state 均指临时文件，--codex-bin
|
||
指假 app-server 脚本，走真实 Server 子进程协议）；
|
||
daemonize 另用子进程脚本验证（双 fork 后写 marker）。
|
||
dispatch 建的 worktree 落在 HERE/work/host-worktrees（已 gitignored），
|
||
tearDown 里逐一清理。
|
||
"""
|
||
|
||
import io
|
||
import json
|
||
import os
|
||
import subprocess
|
||
import sys
|
||
import tempfile
|
||
import time
|
||
import unittest
|
||
from contextlib import redirect_stdout
|
||
from pathlib import Path
|
||
|
||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||
sys.path.insert(0, str(REPO_ROOT))
|
||
|
||
import host
|
||
from host import (
|
||
dispatch,
|
||
dispatch_from_branch,
|
||
merge_task,
|
||
notify_failure,
|
||
run_goal_loop,
|
||
run_health_check,
|
||
run_task_turn,
|
||
run_task_turn_with_retry,
|
||
)
|
||
|
||
HERE = os.path.dirname(os.path.abspath(host.__file__))
|
||
|
||
FAKE_SCRIPT = r'''#!/usr/bin/env python3
|
||
"""假 app-server：只讲 JSON-RPC 行协议，不跑模型。"""
|
||
import json
|
||
import sys
|
||
|
||
|
||
def send(obj):
|
||
sys.stdout.write(json.dumps(obj) + "\n")
|
||
sys.stdout.flush()
|
||
|
||
|
||
def result_for(method):
|
||
if method == "thread/start":
|
||
return {"thread": {"id": "th-1"}}
|
||
if method == "thread/list":
|
||
return {"threads": [{"id": "th-1"}]}
|
||
if method == "thread/resume":
|
||
return {"resumed": True}
|
||
if method == "review/start":
|
||
return {"review": "ok"}
|
||
if method == "thread/fork":
|
||
return {"thread": {"id": "th-2"}}
|
||
if method == "thread/archive":
|
||
return {}
|
||
if method == "turn/interrupt":
|
||
return {"interrupted": True}
|
||
if method == "initialize":
|
||
return {"server": "fake"}
|
||
if method == "turn/start":
|
||
return {"turn": {"id": "turn-1"}}
|
||
return {}
|
||
|
||
|
||
def main():
|
||
for line in sys.stdin:
|
||
line = line.strip()
|
||
if not line:
|
||
continue
|
||
try:
|
||
msg = json.loads(line)
|
||
except ValueError:
|
||
continue
|
||
if "method" not in msg:
|
||
continue
|
||
send({"jsonrpc": "2.0", "id": msg.get("id"),
|
||
"result": result_for(msg["method"])})
|
||
|
||
|
||
main()
|
||
'''
|
||
|
||
USAGE = {"input_tokens": 3, "cached_input_tokens": 0,
|
||
"cache_write_input_tokens": 0, "output_tokens": 1,
|
||
"reasoning_output_tokens": 0, "total_tokens": 4,
|
||
"completions": 1}
|
||
|
||
|
||
class StubServer:
|
||
def __init__(self, results=None):
|
||
self.results = list(results) if results is not None else [
|
||
{"status": "completed", "text": "done\n", "usage": dict(USAGE)}]
|
||
self.created = []
|
||
|
||
def create_thread(self, cwd, model=None, sandbox=None,
|
||
approval_policy=None):
|
||
self.created.append(cwd)
|
||
return "th-1"
|
||
|
||
def run_turn(self, thread_id, prompt, model=None, effort=None,
|
||
sandbox=None, timeout=None, interrupt_file=None):
|
||
if not self.results:
|
||
return {"status": "completed", "text": "done\n",
|
||
"usage": dict(USAGE)}
|
||
result = self.results.pop(0)
|
||
if isinstance(result, Exception):
|
||
raise result
|
||
return result
|
||
|
||
|
||
def _git(repo, *args, check=True):
|
||
return subprocess.run(["git", "-C", repo] + list(args),
|
||
check=check, capture_output=True, text=True)
|
||
|
||
|
||
def _make_repo(path, content="l1\nl2\nl3\nl4\nl5\n"):
|
||
subprocess.run(["git", "init", "-q", path], check=True,
|
||
capture_output=True)
|
||
_git(path, "config", "user.email", "t@t.local")
|
||
_git(path, "config", "user.name", "T")
|
||
with open(os.path.join(path, "f.txt"), "w") as f:
|
||
f.write(content)
|
||
_git(path, "add", ".")
|
||
_git(path, "commit", "-qm", "base")
|
||
return path
|
||
|
||
|
||
class MergeTaskTest(unittest.TestCase):
|
||
def setUp(self):
|
||
self.tmp = tempfile.TemporaryDirectory()
|
||
self.addCleanup(self.tmp.cleanup)
|
||
self.repo = _make_repo(os.path.join(self.tmp.name, "repo"))
|
||
|
||
def _worktree_for_branch(self, branch):
|
||
wt = os.path.join(self.tmp.name, "wt-" + branch.replace("/", "_"))
|
||
_git(self.repo, "worktree", "add", wt, "-b", branch, "HEAD")
|
||
return wt
|
||
|
||
def _head(self):
|
||
return _git(self.repo, "rev-parse", "HEAD").stdout.strip()
|
||
|
||
def test_merge_success_and_verify_rollback(self):
|
||
wt = self._worktree_for_branch("host/t1")
|
||
with open(os.path.join(wt, "f.txt"), "a") as f:
|
||
f.write("task-line\n")
|
||
ok, msg = merge_task(self.repo, wt, "host/t1", "t1",
|
||
verify_command="true")
|
||
self.assertTrue(ok, msg)
|
||
with open(os.path.join(self.repo, "f.txt")) as f:
|
||
self.assertIn("task-line", f.read())
|
||
self.assertEqual(_git(self.repo, "branch", "--list", "host/t1",
|
||
check=False).stdout.strip(), "")
|
||
# 验测失败：回滚到合并前 HEAD，分支与 worktree 保留。
|
||
wt2 = self._worktree_for_branch("host/t2")
|
||
with open(os.path.join(wt2, "f.txt"), "a") as f:
|
||
f.write("bad-line\n")
|
||
pre = self._head()
|
||
ok, msg = merge_task(self.repo, wt2, "host/t2", "t2",
|
||
verify_command="false")
|
||
self.assertFalse(ok)
|
||
self.assertIn("验测失败", msg)
|
||
self.assertEqual(self._head(), pre)
|
||
self.assertIn("host/t2",
|
||
_git(self.repo, "branch", "--list").stdout)
|
||
_git(self.repo, "worktree", "remove", "--force", wt2)
|
||
|
||
def test_merge_conflict_auto_resolve_keeps_branch_lines(self):
|
||
# gap2 同款：主仓与分支在同一位置插入了不同第二行（冲突），
|
||
# 分支的第二行是文件别处已有的行（L09），远处独有改动是
|
||
# L11-task。-X ours 解后分支新增行全在主仓里 -> 成功。
|
||
# 注意 base 必须与两侧共享绝大多数行，否则整文件算一个
|
||
# 冲突块，-X ours 会把远处改动也一起丢掉。
|
||
lfile = "".join("L%02d\n" % i for i in range(1, 13))
|
||
repo2 = _make_repo(os.path.join(self.tmp.name, "repo2"),
|
||
content=lfile)
|
||
with open(os.path.join(repo2, "f.txt"), "w") as f:
|
||
f.write("L01\nL02\nSH\nM1\nL03\nL04\nL05\nL06\nL07\nL08\n"
|
||
"L09\nL10\nL11\nL12\n")
|
||
_git(repo2, "add", ".")
|
||
_git(repo2, "commit", "-qm", "main advance")
|
||
wt = os.path.join(self.tmp.name, "wt-t3")
|
||
_git(repo2, "worktree", "add", wt, "-b", "host/t3", "HEAD~1")
|
||
with open(os.path.join(wt, "f.txt"), "w") as f:
|
||
f.write("L01\nL02\nSH\nL09\nL03\nL04\nL05\nL06\nL07\nL08\n"
|
||
"L09\nL10\nL11-task\nL12\n")
|
||
out = io.StringIO()
|
||
with redirect_stdout(out):
|
||
ok, msg = merge_task(repo2, wt, "host/t3", "t3",
|
||
verify_command="true")
|
||
self.assertTrue(ok, msg)
|
||
self.assertIn("-X ours", out.getvalue())
|
||
with open(os.path.join(repo2, "f.txt")) as f:
|
||
content = f.read()
|
||
self.assertIn("L11-task", content)
|
||
self.assertIn("SH", content)
|
||
|
||
def test_merge_conflict_loses_branch_line_rolls_back(self):
|
||
# 同一行互改、无其它改动：-X ours 解后分支行丢失 -> 回滚。
|
||
with open(os.path.join(self.repo, "f.txt"), "w") as f:
|
||
f.write("l1\nl2\nl3-main\nl4\nl5\n")
|
||
_git(self.repo, "add", ".")
|
||
_git(self.repo, "commit", "-qm", "main advance")
|
||
wt = os.path.join(self.tmp.name, "wt-t4")
|
||
_git(self.repo, "worktree", "add", wt, "-b", "host/t4", "HEAD~1")
|
||
with open(os.path.join(wt, "f.txt"), "w") as f:
|
||
f.write("l1\nl2\nl3-task\nl4\nl5\n")
|
||
pre = self._head()
|
||
ok, msg = merge_task(self.repo, wt, "host/t4", "t4",
|
||
verify_command="true")
|
||
self.assertFalse(ok)
|
||
self.assertIn("改动被丢弃", msg)
|
||
self.assertEqual(self._head(), pre)
|
||
|
||
|
||
class HealthNotifyTest(unittest.TestCase):
|
||
def setUp(self):
|
||
self.tmp = tempfile.TemporaryDirectory()
|
||
self.addCleanup(self.tmp.cleanup)
|
||
self.state_path = os.path.join(self.tmp.name, "host-state.json")
|
||
host.save_state(self.state_path, {"tasks": {}, "automations": []})
|
||
|
||
def test_health_check_variants(self):
|
||
class FakeSrv:
|
||
def __init__(self, ok=True):
|
||
self.ok = ok
|
||
|
||
def initialize(self):
|
||
if not self.ok:
|
||
raise RuntimeError("init boom")
|
||
|
||
def list_threads(self):
|
||
return {"data": [{"id": "th-1"}, {"id": "th-2"}]}
|
||
|
||
def close(self):
|
||
pass
|
||
|
||
bin_path = os.path.join(self.tmp.name, "codex-bin")
|
||
with open(bin_path, "w") as f:
|
||
f.write("#!/bin/sh\n")
|
||
report = run_health_check(self.state_path, {}, bin_path, None,
|
||
"deny",
|
||
server_factory=lambda: FakeSrv(True))
|
||
self.assertTrue(report["ok"])
|
||
self.assertTrue(report["checks"]["codex_bin_exists"])
|
||
self.assertTrue(report["checks"]["state_valid"])
|
||
self.assertTrue(report["checks"]["server_ok"])
|
||
self.assertEqual(report["checks"]["server_threads"], 2)
|
||
self.assertFalse(report["checks"]["backup_exists"])
|
||
with open(self.state_path + ".bak", "w") as f:
|
||
f.write("{}")
|
||
report = run_health_check(self.state_path, {}, bin_path, None,
|
||
"deny",
|
||
server_factory=lambda: FakeSrv(True))
|
||
self.assertTrue(report["checks"]["backup_exists"])
|
||
report = run_health_check(self.state_path, {}, "/nonexistent-bin",
|
||
None, "deny",
|
||
server_factory=lambda: FakeSrv(False))
|
||
self.assertFalse(report["ok"])
|
||
self.assertFalse(report["checks"]["codex_bin_exists"])
|
||
self.assertFalse(report["checks"]["server_ok"])
|
||
self.assertIn("init boom", report["checks"]["server_error"])
|
||
# 损坏的 state：state_valid 为 False，failed 列表为空。
|
||
with open(self.state_path, "w") as f:
|
||
f.write("{broken")
|
||
report = run_health_check(self.state_path, {}, bin_path, None,
|
||
"deny",
|
||
server_factory=lambda: FakeSrv(True))
|
||
self.assertFalse(report["checks"]["state_valid"])
|
||
self.assertEqual(report["checks"]["failed_tasks"], [])
|
||
# 损坏的 pidfile：daemon_alive 为 False（先删掉坏 state 文件，
|
||
# save_state 按设计拒绝在坏文件上重写）。
|
||
pidfile = os.path.join(self.tmp.name, "host-daemon.pid")
|
||
with open(pidfile, "w") as f:
|
||
f.write("not-a-pid")
|
||
os.unlink(self.state_path)
|
||
host.save_state(self.state_path, {"tasks": {}, "automations": []})
|
||
report = run_health_check(self.state_path, {}, bin_path, None,
|
||
"deny",
|
||
server_factory=lambda: FakeSrv(True))
|
||
self.assertFalse(report["checks"]["daemon_alive"])
|
||
self.assertIsNone(report["checks"]["daemon_pid"])
|
||
|
||
def test_notify_failure_variants(self):
|
||
msg = notify_failure(self.state_path, {}, "t1",
|
||
{"status": "failed", "text": "boom"})
|
||
self.assertTrue(msg.startswith("FAILED t1:"))
|
||
log_path = os.path.join(self.tmp.name, "host-run.log")
|
||
with open(log_path) as f:
|
||
self.assertIn("FAILED t1:", f.read())
|
||
marker = os.path.join(self.tmp.name, "notified.txt")
|
||
msg = notify_failure(
|
||
self.state_path, {"notify_command": "echo {task} >> " + marker},
|
||
"t2", {"status": "failed", "text": "x"})
|
||
with open(marker) as f:
|
||
self.assertIn("t2", f.read())
|
||
# 坏模板：不跑命令、记 template error。
|
||
marker2 = os.path.join(self.tmp.name, "notified2.txt")
|
||
notify_failure(
|
||
self.state_path,
|
||
{"notify_command": "echo hi >> " + marker2 + " {unknown}"},
|
||
"t3", {"status": "failed", "text": "x"})
|
||
self.assertFalse(os.path.exists(marker2))
|
||
with open(log_path) as f:
|
||
self.assertIn("template error", f.read())
|
||
# 失败命令：记 rc；注入文本不执行。
|
||
notify_failure(self.state_path, {"notify_command": "false"},
|
||
"t4", {"status": "failed", "text": "x"})
|
||
with open(log_path) as f:
|
||
self.assertIn("notify command rc=1", f.read())
|
||
pwn = os.path.join(self.tmp.name, "pwned")
|
||
notify_failure(
|
||
self.state_path,
|
||
{"notify_command": "echo {text} >> " + marker},
|
||
"t5", {"status": "failed",
|
||
"text": "$(touch %s)" % pwn})
|
||
self.assertFalse(os.path.exists(pwn))
|
||
|
||
|
||
class DaemonizeTest(unittest.TestCase):
|
||
def test_daemonize_double_fork_writes_pidfile_and_marker(self):
|
||
script = os.path.join(tempfile.gettempdir(),
|
||
"cov85_daemon_probe_%d.py" % os.getpid())
|
||
pidfile = os.path.join(tempfile.gettempdir(),
|
||
"cov85_daemon_%d.pid" % os.getpid())
|
||
logfile = os.path.join(tempfile.gettempdir(),
|
||
"cov85_daemon_%d.log" % os.getpid())
|
||
marker = os.path.join(tempfile.gettempdir(),
|
||
"cov85_daemon_%d.marker" % os.getpid())
|
||
for p in (pidfile, logfile, marker):
|
||
if os.path.exists(p):
|
||
os.unlink(p)
|
||
code = (
|
||
"import os, sys\n"
|
||
"sys.path.insert(0, %r)\n"
|
||
"import host\n"
|
||
"cont = host.daemonize(%r, %r)\n"
|
||
"if not cont:\n"
|
||
" sys.exit(42)\n"
|
||
"open(%r, 'w').write(str(os.getpid()))\n"
|
||
% (str(REPO_ROOT), pidfile, logfile, marker))
|
||
with open(script, "w") as f:
|
||
f.write(code)
|
||
try:
|
||
proc = subprocess.run([sys.executable, script],
|
||
capture_output=True, text=True, timeout=30)
|
||
self.assertEqual(proc.returncode, 42)
|
||
deadline = time.time() + 5
|
||
while not os.path.exists(marker) and time.time() < deadline:
|
||
time.sleep(0.05)
|
||
self.assertTrue(os.path.exists(marker))
|
||
with open(pidfile) as f:
|
||
pid_text = f.read().strip()
|
||
with open(marker) as f:
|
||
self.assertEqual(f.read().strip(), pid_text)
|
||
self.assertTrue(os.path.exists(logfile))
|
||
finally:
|
||
for p in (script, pidfile, logfile, marker):
|
||
if os.path.exists(p):
|
||
os.unlink(p)
|
||
|
||
|
||
class DispatchGoalTest(unittest.TestCase):
|
||
def setUp(self):
|
||
self.tmp = tempfile.TemporaryDirectory()
|
||
self.addCleanup(self.tmp.cleanup)
|
||
self.repo = _make_repo(os.path.join(self.tmp.name, "repo"))
|
||
self.state_path = os.path.join(self.tmp.name, "host-state.json")
|
||
self.state = {"tasks": {}, "automations": []}
|
||
self.created_names = []
|
||
|
||
def tearDown(self):
|
||
for name in self.created_names:
|
||
wt = os.path.join(HERE, "work", "host-worktrees", name)
|
||
if os.path.exists(wt):
|
||
subprocess.run(["git", "-C", self.repo, "worktree",
|
||
"remove", "--force", wt],
|
||
capture_output=True)
|
||
subprocess.run(["git", "-C", self.repo, "branch", "-D",
|
||
"host/" + name], capture_output=True)
|
||
self.tmp.cleanup()
|
||
|
||
def test_dispatch_and_existing_and_seed(self):
|
||
srv = StubServer()
|
||
task = dispatch(srv, self.state, "t1", "do thing", self.repo,
|
||
None, None, None, "never")
|
||
self.created_names.append("t1")
|
||
self.assertEqual(task["thread_id"], "th-1")
|
||
self.assertEqual(task["status"], "running")
|
||
self.assertTrue(os.path.isdir(task["cwd"]))
|
||
self.assertIs(self.state["tasks"]["t1"], task)
|
||
with self.assertRaises(RuntimeError):
|
||
dispatch(srv, self.state, "t1", "again", self.repo,
|
||
None, None, None, "never")
|
||
seed = os.path.join(self.tmp.name, "seed")
|
||
os.makedirs(os.path.join(seed, "sub"))
|
||
with open(os.path.join(seed, "a.txt"), "w") as f:
|
||
f.write("seeded")
|
||
with open(os.path.join(seed, "sub", "b.txt"), "w") as f:
|
||
f.write("seeded-sub")
|
||
task2 = dispatch(srv, self.state, "t2", "seeded task", self.repo,
|
||
None, None, None, "never", seed_dir=seed)
|
||
self.created_names.append("t2")
|
||
with open(os.path.join(task2["cwd"], "a.txt")) as f:
|
||
self.assertEqual(f.read(), "seeded")
|
||
with open(os.path.join(task2["cwd"], "sub", "b.txt")) as f:
|
||
self.assertEqual(f.read(), "seeded-sub")
|
||
# seed-dir 没有 worktree 时 loud fail。
|
||
with self.assertRaises(RuntimeError):
|
||
dispatch(srv, self.state, "t3", "x", self.repo,
|
||
None, None, None, "never", use_worktree=False,
|
||
seed_dir=seed)
|
||
with self.assertRaises(RuntimeError):
|
||
dispatch(srv, self.state, "t4", "x", None,
|
||
None, None, None, "never", seed_dir=seed)
|
||
|
||
def test_dispatch_from_branch(self):
|
||
srv = StubServer()
|
||
dep = dispatch(srv, self.state, "dep", "dep work", self.repo,
|
||
None, None, None, "never")
|
||
self.created_names.append("dep")
|
||
with open(os.path.join(dep["cwd"], "dep.txt"), "w") as f:
|
||
f.write("dep-change")
|
||
task, err = dispatch_from_branch(
|
||
srv, self.state, "child", "child work", self.repo,
|
||
dep["branch"], dep["cwd"], None, None, None, "never")
|
||
self.created_names.append("child")
|
||
self.assertEqual(err, "")
|
||
self.assertEqual(task["branch"], "host/child")
|
||
with open(os.path.join(task["cwd"], "dep.txt")) as f:
|
||
self.assertEqual(f.read(), "dep-change")
|
||
task2, err2 = dispatch_from_branch(
|
||
srv, self.state, "child", "again", self.repo,
|
||
dep["branch"], dep["cwd"], None, None, None, "never")
|
||
self.assertIsNone(task2)
|
||
self.assertIn("已存在", err2)
|
||
|
||
def test_run_task_turn_status_mapping_and_retry(self):
|
||
state = {"tasks": {}, "automations": []}
|
||
task = {"name": "r1", "thread_id": "th-1", "status": "running",
|
||
"turns": []}
|
||
srv = StubServer([{"status": "completed", "text": "ok",
|
||
"usage": dict(USAGE)}])
|
||
result = run_task_turn(srv, state, task, "prompt", None, None)
|
||
self.assertEqual(task["status"], "completed")
|
||
self.assertEqual(result["status"], "completed")
|
||
task2 = {"name": "r2", "thread_id": "th-1", "status": "running",
|
||
"turns": []}
|
||
srv2 = StubServer([{"status": "timeout", "text": "partial",
|
||
"usage": dict(USAGE)}])
|
||
run_task_turn(srv2, state, task2, "prompt", None, None)
|
||
self.assertEqual(task2["status"], "interrupted")
|
||
task3 = {"name": "r3", "thread_id": "th-1", "status": "running",
|
||
"turns": []}
|
||
srv3 = StubServer([{"status": "failed", "text": "",
|
||
"usage": dict(USAGE)}])
|
||
run_task_turn(srv3, state, task3, "prompt", None, None)
|
||
self.assertEqual(task3["status"], "failed")
|
||
# 重试：先失败再成功，usage 汇总且 retry_count 为 1。
|
||
task4 = {"name": "r4", "thread_id": "th-1", "status": "running",
|
||
"turns": [], "max_retries": 1}
|
||
srv4 = StubServer([{"status": "failed", "text": "",
|
||
"usage": dict(USAGE)},
|
||
{"status": "completed", "text": "ok",
|
||
"usage": dict(USAGE)}])
|
||
result = run_task_turn_with_retry(srv4, state, task4, "prompt",
|
||
None, None)
|
||
self.assertEqual(result["status"], "completed")
|
||
self.assertEqual(task4["retry_count"], 1)
|
||
self.assertEqual(result["usage"]["input_tokens"], 6)
|
||
# 预算门：cfg 限 1 轮且已用 1 轮时直接失败，不跑 turn。
|
||
today = time.strftime("%Y-%m-%d", time.localtime())
|
||
state2 = {"tasks": {}, "automations": [],
|
||
"usage": {"date": today, "turns": 1, "failed_turns": 0}}
|
||
task5 = {"name": "r5", "thread_id": "th-1", "status": "running",
|
||
"turns": [], "max_retries": 0}
|
||
srv5 = StubServer()
|
||
result = run_task_turn_with_retry(
|
||
srv5, state2, task5, "prompt", None, None,
|
||
cfg={"max_daily_turns": 1})
|
||
self.assertEqual(result["status"], "failed")
|
||
self.assertIn("budget exceeded", result["error"])
|
||
self.assertEqual(task5["status"], "failed")
|
||
|
||
def _goal_state(self, name):
|
||
task = {"name": name, "thread_id": "th-1", "status": "running",
|
||
"turns": [], "cwd": self.tmp.name}
|
||
state = {"tasks": {name: task}, "automations": []}
|
||
return state, task
|
||
|
||
def test_goal_loop_met_by_verify_and_by_marker(self):
|
||
state, task = self._goal_state("g1")
|
||
out = io.StringIO()
|
||
with redirect_stdout(out):
|
||
res = run_goal_loop(StubServer(), state, self.state_path,
|
||
task, "do it", "true", 3, None, None, None)
|
||
self.assertTrue(res["ok"])
|
||
self.assertEqual(task["status"], "goal-met")
|
||
self.assertEqual(res["rounds_done"], 1)
|
||
self.assertIn("goal met after rounds", out.getvalue())
|
||
state, task = self._goal_state("g2")
|
||
srv = StubServer([{"status": "completed",
|
||
"text": "work done\n目标已达成\n",
|
||
"usage": dict(USAGE)}])
|
||
res = run_goal_loop(srv, state, self.state_path, task, "do it",
|
||
None, 3, None, None, None)
|
||
self.assertTrue(res["ok"])
|
||
self.assertEqual(task["status"], "goal-met")
|
||
|
||
def test_goal_loop_unmet_budget_and_exception(self):
|
||
state, task = self._goal_state("g3")
|
||
res = run_goal_loop(StubServer(), state, self.state_path, task,
|
||
"do it", "false", 1, None, None, None)
|
||
self.assertFalse(res["ok"])
|
||
self.assertEqual(task["status"], "goal-unmet")
|
||
self.assertEqual(res["rounds_done"], 1)
|
||
today = time.strftime("%Y-%m-%d", time.localtime())
|
||
state, task = self._goal_state("g4")
|
||
state["usage"] = {"date": today, "turns": 5, "failed_turns": 0}
|
||
res = run_goal_loop(StubServer(), state, self.state_path, task,
|
||
"do it", "true", 3, None, None, None,
|
||
cfg={"max_daily_turns": 3})
|
||
self.assertTrue(res["budget_stopped"])
|
||
self.assertEqual(task["status"], "interrupted")
|
||
state, task = self._goal_state("g5")
|
||
srv = StubServer([RuntimeError("turn boom")])
|
||
res = run_goal_loop(srv, state, self.state_path, task, "do it",
|
||
"true", 3, None, None, None)
|
||
self.assertTrue(res["interrupted"])
|
||
self.assertEqual(task["status"], "interrupted")
|
||
self.assertIn("turn boom", task["goal_interrupted_reason"])
|
||
|
||
|
||
class MainCommandsTest(unittest.TestCase):
|
||
def setUp(self):
|
||
self.tmp = tempfile.TemporaryDirectory()
|
||
self.addCleanup(self.tmp.cleanup)
|
||
self.repo = _make_repo(os.path.join(self.tmp.name, "repo"))
|
||
self.config_path = os.path.join(self.tmp.name, "host-config.json")
|
||
with open(self.config_path, "w") as f:
|
||
json.dump({}, f)
|
||
self.state_path = os.path.join(self.tmp.name, "host-state.json")
|
||
self.fake_bin = os.path.join(self.tmp.name, "fake-codex.py")
|
||
with open(self.fake_bin, "w") as f:
|
||
f.write(FAKE_SCRIPT)
|
||
os.chmod(self.fake_bin, 0o755)
|
||
self._old_argv = sys.argv
|
||
self.created_names = []
|
||
|
||
def tearDown(self):
|
||
sys.argv = self._old_argv
|
||
for name in self.created_names:
|
||
wt = os.path.join(HERE, "work", "host-worktrees", name)
|
||
if os.path.exists(wt):
|
||
subprocess.run(["git", "-C", self.repo, "worktree",
|
||
"remove", "--force", wt],
|
||
capture_output=True)
|
||
subprocess.run(["git", "-C", self.repo, "branch", "-D",
|
||
"host/" + name], capture_output=True)
|
||
self.tmp.cleanup()
|
||
|
||
def _main(self, *argv):
|
||
sys.argv = ["host.py", "--config", self.config_path,
|
||
"--state", self.state_path] + list(argv)
|
||
out = io.StringIO()
|
||
with redirect_stdout(out):
|
||
host.main()
|
||
return out.getvalue()
|
||
|
||
def _main_code(self, *argv):
|
||
sys.argv = ["host.py", "--config", self.config_path,
|
||
"--state", self.state_path] + list(argv)
|
||
out = io.StringIO()
|
||
with redirect_stdout(out):
|
||
try:
|
||
host.main()
|
||
except SystemExit as exc:
|
||
return exc.code, out.getvalue()
|
||
return 0, out.getvalue()
|
||
|
||
def _load_state(self):
|
||
with open(self.state_path) as f:
|
||
return json.load(f)
|
||
|
||
def test_init_config_doctor_failures(self):
|
||
os.unlink(self.config_path)
|
||
out = self._main("init", "--repo", self.repo)
|
||
self.assertIn("配置文件已写", out)
|
||
out = self._main("init")
|
||
self.assertIn("配置文件已存在", out)
|
||
out = self._main("config")
|
||
cfg = json.loads(out)
|
||
self.assertEqual(cfg["model"], "gpt-5.6-terra")
|
||
out = self._main("doctor")
|
||
doc = json.loads(out)
|
||
self.assertEqual(doc["failed_tasks"], [])
|
||
out = self._main("failures")
|
||
self.assertEqual(json.loads(out), {"failed_tasks": []})
|
||
host.save_state(self.state_path,
|
||
{"tasks": {"bad": {"name": "bad",
|
||
"status": "failed"}},
|
||
"automations": []})
|
||
out = self._main("failures")
|
||
self.assertEqual(json.loads(out), {"failed_tasks": ["bad"]})
|
||
|
||
def test_health_good_and_bad(self):
|
||
out = self._main("--codex-bin", self.fake_bin, "health")
|
||
report = json.loads(out)
|
||
self.assertTrue(report["ok"])
|
||
self.assertTrue(report["checks"]["server_ok"])
|
||
code, out = self._main_code("--codex-bin", "/nonexistent-bin",
|
||
"health")
|
||
self.assertEqual(code, 1)
|
||
report = json.loads(out)
|
||
self.assertFalse(report["ok"])
|
||
|
||
def test_daemon_status_stop_and_sleep(self):
|
||
out = self._main("daemon-status")
|
||
doc = json.loads(out)
|
||
self.assertFalse(doc["alive"])
|
||
self.assertIsNone(doc["pid"])
|
||
out = self._main("daemon-stop")
|
||
self.assertIn("daemon 未运行", out)
|
||
pidfile = os.path.join(self.tmp.name, "host-daemon.pid")
|
||
with open(pidfile, "w") as f:
|
||
f.write("garbage")
|
||
out = self._main("daemon-stop")
|
||
self.assertIn("pidfile 损坏", out)
|
||
self.assertFalse(os.path.exists(pidfile))
|
||
out = self._main("sleep", "--seconds", "0")
|
||
self.assertEqual(json.loads(out)["slept_seconds"], 0)
|
||
code, _ = self._main_code("sleep", "--seconds", "61")
|
||
self.assertEqual(code, 1)
|
||
|
||
def test_github_workflow_pr_and_review_comment(self):
|
||
code, _ = self._main_code("github-workflow")
|
||
self.assertEqual(code, 1)
|
||
code, _ = self._main_code("pr", "--task", "missing")
|
||
self.assertEqual(code, 1)
|
||
host.save_state(self.state_path,
|
||
{"tasks": {"t1": {"name": "t1",
|
||
"thread_id": "th-1",
|
||
"status": "completed",
|
||
"review_comments": []}},
|
||
"automations": []})
|
||
out = self._main("review-comment", "--task", "t1",
|
||
"--file", "a.py", "--line", "3",
|
||
"--comment", "fix this")
|
||
comment = json.loads(out)
|
||
self.assertEqual(comment["file"], "a.py")
|
||
self.assertEqual(comment["line"], 3)
|
||
state = self._load_state()
|
||
self.assertEqual(len(state["tasks"]["t1"]["review_comments"]), 1)
|
||
out = self._main("discard", "--task", "missing")
|
||
self.assertIn("任务不存在", out)
|
||
out = self._main("discard", "--task", "t1")
|
||
self.assertIn("discarded t1", out)
|
||
state = self._load_state()
|
||
self.assertEqual(state["tasks"]["t1"]["status"], "discarded")
|
||
|
||
def test_automations_cron_line_restore_recover(self):
|
||
out = self._main("automations", "--cron-line")
|
||
self.assertIn("codex-host-run-due", out)
|
||
out = self._main("restore-state")
|
||
self.assertIn("state 完好", out)
|
||
out = self._main("recover")
|
||
self.assertEqual(json.loads(out), {"recovered": []})
|
||
|
||
def test_dispatch_status_list_threads_and_run(self):
|
||
self.created_names.append("dtask")
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"--turn-timeout", "1",
|
||
"dispatch", "--name", "dtask",
|
||
"--task", "do thing", "--repo", self.repo)
|
||
info = json.loads(out)
|
||
self.assertEqual(info["task"], "dtask")
|
||
self.assertEqual(info["thread_id"], "th-1")
|
||
state = self._load_state()
|
||
self.assertEqual(state["tasks"]["dtask"]["status"], "interrupted")
|
||
out = self._main("status", "--task", "dtask")
|
||
self.assertEqual(json.loads(out)["name"], "dtask")
|
||
out = self._main("--codex-bin", self.fake_bin, "list")
|
||
self.assertIn("dtask", out)
|
||
out = self._main("--codex-bin", self.fake_bin, "thread-list")
|
||
self.assertIn("th-1", out)
|
||
out = self._main("--codex-bin", self.fake_bin, "skills-list")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin, "apps-list")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin, "mcp-servers-list")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin, "mcp-servers-reload")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"thread-read", "--thread-id", "th-1")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"thread-rename", "--thread-id", "th-1",
|
||
"--name", "renamed")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"thread-archive", "--thread-id", "th-1")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"thread-unarchive", "--thread-id", "th-1")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"thread-compact", "--thread-id", "th-1")
|
||
self.assertEqual(json.loads(out), {})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"--turn-timeout", "1",
|
||
"run", "--task", "dtask", "--prompt", "again")
|
||
result = json.loads(out)
|
||
self.assertEqual(result["status"], "timeout")
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"compact", "--task", "dtask")
|
||
self.assertIn("compact dtask", out)
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"archive", "--task", "dtask")
|
||
self.assertIn("archived dtask", out)
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"code-review", "--task", "dtask",
|
||
"--instructions", "look carefully")
|
||
self.assertIn("code-review dtask", out)
|
||
self.assertIn("review", out)
|
||
|
||
def test_fork_delegate_interrupt_and_merge(self):
|
||
self.created_names.append("ptask")
|
||
self.created_names.append("ftask")
|
||
self._main("--codex-bin", self.fake_bin,
|
||
"--turn-timeout", "1",
|
||
"dispatch", "--name", "ptask",
|
||
"--task", "parent work", "--repo", self.repo)
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"fork", "--task", "ptask", "--name", "ftask")
|
||
self.assertIn("forked ptask -> ftask", out)
|
||
self.assertIn("thread=th-2", out)
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"--turn-timeout", "1",
|
||
"delegate", "--parent-task", "ptask",
|
||
"--task", "sub1", "--name", "sub1")
|
||
doc = json.loads(out)
|
||
self.assertEqual(doc["sub_task"], "sub1")
|
||
# 中断：无 turn_id 与有 turn_id 两路。
|
||
host.save_state(self.state_path,
|
||
{"tasks": {"it": {"name": "it",
|
||
"thread_id": "th-1",
|
||
"status": "running",
|
||
"turns": []}},
|
||
"automations": []})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"interrupt", "--task", "it")
|
||
self.assertIn("没有可中断的 turn_id", out)
|
||
host.save_state(self.state_path,
|
||
{"tasks": {"it": {"name": "it",
|
||
"thread_id": "th-1",
|
||
"status": "running",
|
||
"turns": [{"result": {
|
||
"turn_id": "turn-1",
|
||
"status": "completed"}}]}},
|
||
"automations": []})
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"interrupt", "--task", "it")
|
||
self.assertIn("turn=turn-1", out)
|
||
state = self._load_state()
|
||
self.assertEqual(state["tasks"]["it"]["status"], "interrupted")
|
||
# merge：ptask 的 worktree 无改动，合并即成功。
|
||
out = self._main("merge", "--task", "ptask")
|
||
self.assertIn("merged", out)
|
||
# goal-resume 对不存在的任务拒绝。
|
||
out = self._main("--codex-bin", self.fake_bin,
|
||
"goal-resume", "--task", "missing")
|
||
self.assertIn("拒绝", out)
|
||
# pr 对有任务但无 gh 时退出 1。
|
||
code, _ = self._main_code("pr", "--task", "ptask")
|
||
self.assertEqual(code, 1)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|