"""覆盖率 78%->85% 第 4 步：host.py main() 剩余分支的真实行为测试。 进程内调 host.main()（--config/--state 均指临时文件）， app-server 一律用 FakeServer（不拉真实 codex 进程）， git 操作走临时仓库；daemon 前台循环用信号停、interrupt 慢路径实测 10 秒等待；绝不跑模型。 """ import io import json import os import signal import subprocess import sys import tempfile import threading import time import unittest from contextlib import redirect_stdout from unittest import mock import host class FakeServer: def __init__(self, **kwargs): self.calls = [] self.results = { "thread/list": {"data": [{"id": "th-1"}]}, "thread/read": {"thread": {"id": "th-1"}}, "thread/name/set": {}, "thread/archive": {}, "thread/unarchive": {"thread": {"id": "th-1"}}, "thread/compact/start": {}, "skills/list": {}, "app/list": {}, "mcpServerStatus/list": {}, "config/mcpServer/reload": {}, "mcpServer/oauth/login": {}, } self.error_methods = set() self.raise_systemexit = set() self.raise_runtime = set() self.interrupt_result = {"result": {}} self.trace_path = None def initialize(self): self.calls.append(("initialize",)) return {} def close(self): self.calls.append(("close",)) def set_trace_file(self, state_path, task_name): self.trace_path = os.path.join( os.path.dirname(state_path), "host-traces", task_name + ".jsonl") def request(self, method, params=None, timeout=120): self.calls.append(("request", method, params)) if method in self.raise_systemexit: raise SystemExit(3) if method in self.raise_runtime: raise RuntimeError("boom-" + method) if method in self.error_methods: return {"error": {"message": "boom"}} return {"result": self.results.get(method, {})} def resume_thread(self, thread_id): self.calls.append(("resume", thread_id)) return {"thread": {"id": thread_id}} def archive_thread(self, thread_id): self.calls.append(("archive", thread_id)) if "thread/archive" in self.raise_systemexit: raise SystemExit(3) if "thread/archive" in self.raise_runtime: raise RuntimeError("boom-thread/archive") return {"result": {}} def list_threads(self): return [{"id": "th-1"}] def create_thread(self, *args, **kwargs): self.calls.append(("create_thread", args, kwargs)) return "th-new" def fork_thread(self, thread_id, **kwargs): self.calls.append(("fork", thread_id, kwargs)) return "th-fork" def interrupt_turn(self, thread_id, turn_id): self.calls.append(("interrupt", thread_id, turn_id)) return self.interrupt_result def start_review(self, thread_id, target): self.calls.append(("review", thread_id, target)) return {"review": "ok"} class Main3Base(unittest.TestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() self.addCleanup(self.tmp.cleanup) self.config_path = os.path.join(self.tmp.name, "cfg.json") self.state_path = os.path.join(self.tmp.name, "host-state.json") with open(self.config_path, "w") as f: json.dump({}, f) self._old_argv = sys.argv def tearDown(self): sys.argv = self._old_argv def _save_state(self, state): host.save_state(self.state_path, state) def _load_state(self): with open(self.state_path) as f: return json.load(f) def _run(self, fake, *argv, **patches): sys.argv = ["host.py", "--config", self.config_path, "--state", self.state_path] + list(argv) out = io.StringIO() code = 0 ctxs = [mock.patch.object(host, "Server", lambda **kw: fake)] for name, val in patches.items(): ctxs.append(mock.patch.object(host, name, val)) with ctxs[0]: if len(ctxs) > 1: with ctxs[1]: if len(ctxs) > 2: with ctxs[2]: code, out = self._invoke(out) else: code, out = self._invoke(out) else: code, out = self._invoke(out) return code, out.getvalue() def _invoke(self, out): code = 0 with redirect_stdout(out): try: host.main() except SystemExit as exc: code = exc.code if isinstance(exc.code, int) else 1 except RuntimeError: code = "runtime-error" return code, out def _git(self, *args, cwd=None): subprocess.run(["git"] + list(args), cwd=cwd, check=True, capture_output=True) def _make_repo(self): repo = os.path.join(self.tmp.name, "repo") os.makedirs(repo) self._git("init", "-q", cwd=repo) self._git("config", "user.email", "t@t.test", cwd=repo) self._git("config", "user.name", "t", cwd=repo) with open(os.path.join(repo, "f.txt"), "w") as f: f.write("hello\n") self._git("add", ".", cwd=repo) self._git("commit", "-qm", "init", cwd=repo) return repo class EarlyBranchesTest(Main3Base): def test_dispatch_without_repo_raises(self): sys.argv = ["host.py", "--config", self.config_path, "--state", self.state_path, "dispatch", "--name", "x", "--task", "y"] with self.assertRaises(RuntimeError) as ctx: host.main() self.assertIn("缺少 --repo", str(ctx.exception)) def test_install_cron_new_and_existing(self): calls = [] def fake_run(cmd, **kw): calls.append(cmd) if cmd[:2] == ["crontab", "-l"]: return mock.Mock(stdout="") return mock.Mock(stdout="", returncode=0) with mock.patch.object(host.subprocess, "run", fake_run): code, out = self._run(FakeServer(), "automations", "--install-cron") self.assertEqual(code, 0) self.assertIn("已安装 crontab", out) self.assertIn("codex-host-run-due", out) def fake_run2(cmd, **kw): if cmd[:2] == ["crontab", "-l"]: return mock.Mock(stdout="*/30 * * * * x " "codex-host-run-due\n") raise AssertionError("不应再写 crontab") with mock.patch.object(host.subprocess, "run", fake_run2): code, out = self._run(FakeServer(), "automations", "--install-cron") self.assertIn("已有 codex-host-run-due", out) def test_github_workflow_success(self): repo = self._make_repo() with open(self.config_path, "w") as f: json.dump({"repo": repo}, f) code, out = self._run(FakeServer(), "github-workflow") self.assertEqual(code, 0) doc = json.loads(out) self.assertTrue(doc["changed"]) self.assertTrue(os.path.exists(doc["path"])) code, out = self._run(FakeServer(), "github-workflow") self.assertFalse(json.loads(out)["changed"]) def test_pr_variants(self): self._save_state({"tasks": {"t1": {"name": "t1", "thread_id": "th-1", "status": "completed", "repo": "/tmp"}}, "automations": []}) code, out = self._run( FakeServer(), "pr", "--task", "t1", create_pr=lambda repo, t: {"url": "https://pr/1"}) self.assertEqual(code, 0) self.assertIn("https://pr/1", out) code, out = self._run( FakeServer(), "pr-checks", "--task", "t1", get_pr_checks=lambda t, repo=None: {"checks": []}) self.assertEqual(code, 0) self.assertIn("checks", out) code, out = self._run( FakeServer(), "pr-merge", "--task", "t1", merge_pr=lambda t, repo=None: (True, "merged ok")) self.assertEqual(code, 0) self.assertIn("merged", out) code, out = self._run( FakeServer(), "pr-merge", "--task", "t1", merge_pr=lambda t, repo=None: (False, "checks pending")) self.assertEqual(code, 1) self.assertIn("checks pending", out) def test_sleep_positive_and_keyboard_interrupt(self): code, out = self._run(FakeServer(), "sleep", "--seconds", "0.5") self.assertEqual(code, 0) self.assertAlmostEqual(json.loads(out)["slept_seconds"], 0.5, places=1) with mock.patch.object(host.time, "sleep", side_effect=KeyboardInterrupt): code, out = self._run(FakeServer(), "sleep", "--seconds", "5") self.assertEqual(code, 130) self.assertTrue(json.loads(out)["interrupted"]) def test_health_not_ok_exits_1(self): code, out = self._run(FakeServer(), "--codex-bin", "/nonexistent-bin", "health") self.assertEqual(code, 1) self.assertFalse(json.loads(out)["ok"]) def test_restore_state_failure_exits_1(self): with open(self.state_path, "w") as f: f.write("{broken json") code, out = self._run(FakeServer(), "restore-state") self.assertEqual(code, 1) def test_recover_corrupt_and_recovered(self): with open(self.state_path, "w") as f: f.write("{broken json") code, out = self._run(FakeServer(), "recover") self.assertEqual(code, 1) self.assertIn("state 已损坏", out) # save_state 拒绝覆盖损坏文件：先删掉再写新 state。 os.remove(self.state_path) self._save_state({"tasks": {"old": {"name": "old", "status": "running", "created_at": 1000}}, "automations": []}) code, out = self._run(FakeServer(), "recover", "--older-than", "0") self.assertEqual(code, 0) self.assertEqual(json.loads(out), {"recovered": ["old"]}) self.assertEqual( self._load_state()["tasks"]["old"]["status"], "interrupted") class DaemonBranchesTest(Main3Base): def _pidfile(self): return os.path.join(self.tmp.name, "host-daemon.pid") def _logfile(self): return os.path.join(self.tmp.name, "host-daemon.log") def test_daemon_status_alive_with_log_tail(self): with open(self._pidfile(), "w") as f: f.write(str(os.getpid())) with open(self._logfile(), "w") as f: f.write("\n".join("line-%d" % i for i in range(7))) code, out = self._run(FakeServer(), "daemon-status") self.assertEqual(code, 0) doc = json.loads(out) self.assertTrue(doc["alive"]) self.assertEqual(doc["pid"], os.getpid()) self.assertIn("line-6", doc["log_tail"]) self.assertNotIn("line-0", doc["log_tail"]) def test_daemon_stop_live_process(self): proc = subprocess.Popen(["sleep", "30"]) try: with open(self._pidfile(), "w") as f: f.write(str(proc.pid)) code, out = self._run(FakeServer(), "daemon-stop") self.assertEqual(code, 0) self.assertIn("daemon 已停", out) self.assertFalse(os.path.exists(self._pidfile())) self.assertIsNotNone(proc.poll()) finally: if proc.poll() is None: proc.kill() proc.wait() def test_daemon_already_running(self): with open(self._pidfile(), "w") as f: f.write(str(os.getpid())) code, out = self._run(FakeServer(), "daemon") self.assertEqual(code, 0) self.assertIn("daemon 已在运行", out) def test_daemon_foreground_loop_stops_on_sigterm(self): self._save_state({"tasks": {}, "automations": []}) # 注意：daemon 循环的子进程只带 --config 不带 --state， # 会写 host.py 所在目录的默认 host-state.json（含 .bak # 轮转）。测试前快照、跑后恢复/删除，不污染 worktree。 here = os.path.dirname(os.path.abspath(host.__file__)) leaked = [os.path.join(here, n) for n in ["host-state.json", "host-state.json.bak", "host-state.json.bak.1", "host-state.json.bak.2", "host-state.json.bak.3"]] snapshot = {} for path in leaked: if os.path.exists(path): with open(path, "rb") as f: snapshot[path] = f.read() old_term = signal.getsignal(signal.SIGTERM) old_int = signal.getsignal(signal.SIGINT) try: def _killer(): time.sleep(0.8) os.kill(os.getpid(), signal.SIGTERM) th = threading.Thread(target=_killer, daemon=True) th.start() code, out = self._run(FakeServer(), "daemon", "--foreground", "--interval", "0") self.assertEqual(code, 0) self.assertIn("host daemon stopped", out) self.assertIn("daemon tick", out) finally: signal.signal(signal.SIGTERM, old_term) signal.signal(signal.SIGINT, old_int) for path in leaked: if path in snapshot: with open(path, "wb") as f: f.write(snapshot[path]) elif os.path.exists(path): os.remove(path) class DispatchReviewMergeTest(Main3Base): def test_dispatch_budget_gate(self): today = time.strftime("%Y-%m-%d", time.localtime()) with open(self.config_path, "w") as f: json.dump({"max_daily_turns": 5}, f) self._save_state({"tasks": {}, "automations": [], "usage": {"date": today, "turns": 5}}) repo = self._make_repo() code, out = self._run(FakeServer(), "dispatch", "--name", "x", "--task", "y", "--repo", repo) self.assertEqual(code, 0) self.assertIn("预算已用完", out) def test_review_with_open_comments(self): repo = self._make_repo() with open(os.path.join(repo, "f.txt"), "a") as f: f.write("more\n") self._save_state({"tasks": {"t1": {"name": "t1", "thread_id": "th-1", "status": "completed", "cwd": repo, "review_comments": [ {"file": "a.py", "line": 3, "comment": "fix", "status": "open"}]}}, "automations": []}) code, out = self._run(FakeServer(), "review", "--task", "t1") self.assertEqual(code, 0) self.assertIn("open review comments", out) self.assertIn("a.py:3: fix", out) def test_merge_non_git_and_failed(self): self._save_state({"tasks": {"t1": {"name": "t1", "thread_id": "th-1", "status": "completed"}}, "automations": []}) code, out = self._run(FakeServer(), "merge", "--task", "t1") self.assertEqual(code, 0) self.assertIn("非 git worktree", out) self._save_state({"tasks": {"t1": {"name": "t1", "thread_id": "th-1", "status": "completed", "repo": "/tmp", "branch": "b", "cwd": "/tmp"}}, "automations": []}) code, out = self._run( FakeServer(), "merge", "--task", "t1", merge_task=lambda *a, **k: (False, "verify failed")) self.assertEqual(code, 0) self.assertIn("verify failed", out) self.assertEqual( self._load_state()["tasks"]["t1"]["status"], "merge-failed") def test_fix_review_completed_and_failed(self): base = {"name": "t1", "thread_id": "th-1", "status": "completed", "cwd": "/tmp", "review_comments": [{"file": "a.py", "line": 1, "comment": "fix", "status": "open"}]} self._save_state({"tasks": {"t1": dict(base)}, "automations": []}) code, out = self._run( FakeServer(), "fix-review", "--task", "t1", run_task_turn=lambda *a, **k: {"status": "completed"}) self.assertEqual(code, 0) self.assertIn("fix-review completed", out) state = self._load_state() self.assertEqual( state["tasks"]["t1"]["review_comments"][0]["status"], "resolved") self._save_state({"tasks": {"t1": dict(base)}, "automations": []}) code, out = self._run( FakeServer(), "fix-review", "--task", "t1", run_task_turn=lambda *a, **k: {"status": "failed", "text": "bad"}) self.assertEqual(code, 0) self.assertIn("fix-review failed", out) def test_discard_with_repo_branch(self): repo = self._make_repo() wt = os.path.join(self.tmp.name, "wt1") self._git("worktree", "add", wt, "-b", "host/t1", cwd=repo) self._save_state({"tasks": {"t1": {"name": "t1", "thread_id": "th-1", "status": "completed", "repo": repo, "branch": "host/t1", "cwd": wt}}, "automations": []}) code, out = self._run(FakeServer(), "discard", "--task", "t1") self.assertEqual(code, 0) self.assertIn("discarded t1", out) self.assertFalse(os.path.exists(wt)) class ThreadErrorBranchesTest(Main3Base): COMMANDS = [ (["thread-list"], "thread/list"), (["thread-read", "--thread-id", "th-1"], "thread/read"), (["thread-rename", "--thread-id", "th-1", "--name", "n"], "thread/name/set"), (["thread-archive", "--thread-id", "th-1"], "thread/archive"), (["thread-unarchive", "--thread-id", "th-1"], "thread/unarchive"), (["thread-compact", "--thread-id", "th-1"], "thread/compact/start"), (["skills-list"], "skills/list"), (["apps-list"], "app/list"), (["mcp-servers-list"], "mcpServerStatus/list"), (["mcp-servers-reload"], "config/mcpServer/reload"), (["mcp-server-oauth-login", "--server-name", "s1"], "mcpServer/oauth/login"), ] def test_thread_commands_systemexit_reraise(self): for argv, method in self.COMMANDS: with self.subTest(argv=argv): fake = FakeServer() fake.raise_systemexit = {method} code, out = self._run(fake, *argv) self.assertEqual(code, 3) def test_thread_commands_runtime_error_json(self): for argv, method in self.COMMANDS: with self.subTest(argv=argv): fake = FakeServer() fake.raise_runtime = {method} code, out = self._run(fake, *argv) self.assertEqual(code, 1) self.assertIn("boom-" + method, out) class CodeReviewInterruptDelegateGoalTest(Main3Base): def _task(self, **kw): d = {"name": "t1", "thread_id": "th-1", "status": "completed", "cwd": "/tmp", "verify_command": ""} d.update(kw) return d def test_code_review_targets(self): self._save_state({"tasks": {"t1": self._task()}, "automations": []}) fake = FakeServer() code, out = self._run(fake, "code-review", "--task", "t1", "--commit", "abc123") self.assertEqual(code, 0) self.assertEqual(fake.calls[-2][2]["type"], "commit") fake = FakeServer() code, out = self._run(fake, "code-review", "--task", "t1", "--base-branch", "main") self.assertEqual(code, 0) self.assertEqual(fake.calls[-2][2]["type"], "baseBranch") fake = FakeServer() code, out = self._run(fake, "code-review", "--task", "t1") self.assertEqual(code, 0) self.assertEqual(fake.calls[-2][2]["type"], "uncommittedChanges") def test_code_review_failure(self): self._save_state({"tasks": {"t1": self._task()}, "automations": []}) fake = FakeServer() def _boom(thread_id, target): raise RuntimeError("review 炸了") fake.start_review = _boom code, out = self._run(fake, "code-review", "--task", "t1") self.assertEqual(code, 1) self.assertIn("code-review failed", out) def test_interrupt_slow_path_waits_ten_seconds(self): self._save_state({"tasks": {"it": { "name": "it", "thread_id": "th-1", "status": "running", "turns": [{"result": {"turn_id": "turn-1", "status": "completed"}}]}}, "automations": []}) fake = FakeServer() fake.interrupt_result = {"error": {"message": "no active turn"}} started = time.time() code, out = self._run(fake, "interrupt", "--task", "it") elapsed = time.time() - started self.assertEqual(code, 0) self.assertGreaterEqual(elapsed, 9.5) self.assertIn("属主 10 秒内未响应", out) def test_interrupt_write_failure(self): self._save_state({"tasks": {"it": { "name": "it", "thread_id": "th-1", "status": "running", "turns": [{"result": {"turn_id": "turn-1", "status": "completed"}}]}}, "automations": []}) req = host._interrupt_request_path(self.state_path, "it") os.makedirs(req, exist_ok=True) fake = FakeServer() fake.interrupt_result = {"error": {"message": "no active turn"}} code, out = self._run(fake, "interrupt", "--task", "it") self.assertEqual(code, 0) self.assertIn("写中断请求失败", out) def test_delegate_report_to_parent(self): self._save_state({"tasks": {"pt": { "name": "pt", "thread_id": "th-1", "status": "running", "cwd": "/tmp"}}, "automations": []}) fake = FakeServer() code, out = self._run( fake, "delegate", "--parent-task", "pt", "--task", "sub", "--name", "sub1", "--report-to-parent", run_task_turn=lambda *a, **k: {"status": "completed", "text": "sub done"}) self.assertEqual(code, 0) self.assertIn("reported to parent", out) state = self._load_state() self.assertEqual(state["tasks"]["sub1"]["status"], "running") def test_goal_branch_wiring(self): repo = self._make_repo() code, out = self._run( FakeServer(), "goal", "--name", "g1", "--task", "达成目标", "--repo", repo, run_goal_loop=lambda *a, **k: None) self.assertEqual(code, 0) state = self._load_state() self.assertIn("g1", state["tasks"]) # 真实 dispatch 在 HERE/work 下建了 worktree + 分支， # 本测试负责清掉，不留脏 worktree。 wt = state["tasks"]["g1"]["cwd"] branch = state["tasks"]["g1"]["branch"] subprocess.run(["git", "-C", repo, "worktree", "remove", "--force", wt], capture_output=True) subprocess.run(["git", "-C", repo, "branch", "-D", branch], capture_output=True) def test_goal_resume_guards_and_rounds(self): # 已终局拒绝。 self._save_state({"tasks": {"t1": self._task( status="completed", goal="做周报")}, "automations": []}) code, out = self._run(FakeServer(), "goal-resume", "--task", "t1") self.assertIn("已终局", out) # goal-running 但无 goal 记录拒绝。 self._save_state({"tasks": {"t1": self._task( status="goal-running")}, "automations": []}) code, out = self._run(FakeServer(), "goal-resume", "--task", "t1") self.assertIn("没有 goal 记录", out) # 轮次来源三路：CLI 覆盖 / 任务原值 / 缺省 3。 seen = {} def _loop(srv, state, state_path, task, goal, verify, max_rounds, *a, **k): seen["max_rounds"] = max_rounds seen["start_round"] = k.get("start_round") self._save_state({"tasks": {"t1": self._task( status="goal-running", goal="做周报", goal_max_rounds=7, goal_rounds_done=2)}, "automations": []}) code, out = self._run(FakeServer(), "goal-resume", "--task", "t1", run_goal_loop=_loop) self.assertEqual(seen["max_rounds"], 7) self.assertEqual(seen["start_round"], 3) code, out = self._run(FakeServer(), "goal-resume", "--task", "t1", "--max-rounds", "2", run_goal_loop=_loop) self.assertEqual(seen["max_rounds"], 2) self._save_state({"tasks": {"t1": self._task( status="goal-running", goal="做周报")}, "automations": []}) code, out = self._run(FakeServer(), "goal-resume", "--task", "t1", run_goal_loop=_loop) self.assertEqual(seen["max_rounds"], 3) # 旧验收形态 0 轮次钳制到 100。 self._save_state({"tasks": {"t1": self._task( status="goal-running", goal="做周报", verify_command="make test", goal_max_rounds=0)}, "automations": []}) code, out = self._run(FakeServer(), "goal-resume", "--task", "t1", run_goal_loop=_loop) self.assertEqual(seen["max_rounds"], 100) class ParallelAutomationsTest(Main3Base): def test_parallel_simple_and_blocked(self): jobs_path = os.path.join(self.tmp.name, "jobs.json") with open(jobs_path, "w") as f: json.dump([ {"name": "a", "task": "做 A"}, {"name": "b", "task": "做 B", "depends_on": ["a"]}, ], f) self._save_state({"tasks": {}, "automations": []}) def _run_turn(srv, state, task, prompt, model, effort, sandbox, **kw): if task["name"] == "a": task["status"] = "failed" return {"status": "failed", "text": "a bad"} task["status"] = "completed" return {"status": "completed", "text": "ok"} code, out = self._run( FakeServer(), "parallel", "--jobs", jobs_path, run_task_turn_with_retry=_run_turn) self.assertEqual(code, 0) self.assertIn("skipped (依赖失败)", out) state = self._load_state() self.assertEqual(state["tasks"]["b"]["status"], "skipped") def test_parallel_unpushable_remaining(self): # 依赖既未完成也未失败/跳过（如 interrupted）：既不进 # blocked 也不进 ready，循环以“无法推进”收尾。 jobs_path = os.path.join(self.tmp.name, "jobs.json") with open(jobs_path, "w") as f: json.dump([ {"name": "a", "task": "做 A"}, {"name": "b", "task": "做 B", "depends_on": ["a"]}, ], f) self._save_state({"tasks": {}, "automations": []}) def _run_turn(srv, state, task, prompt, model, effort, sandbox, **kw): task["status"] = "interrupted" return {"status": "interrupted", "text": "cut"} code, out = self._run( FakeServer(), "parallel", "--jobs", jobs_path, run_task_turn_with_retry=_run_turn) self.assertEqual(code, 0) self.assertIn("无法推进", out) state = self._load_state() self.assertNotIn("b", state["tasks"]) def test_parallel_with_repo_dependency(self): repo = self._make_repo() jobs_path = os.path.join(self.tmp.name, "jobs.json") with open(jobs_path, "w") as f: json.dump([ {"name": "a", "task": "做 A", "repo": repo}, {"name": "b", "task": "做 B", "repo": repo, "depends_on": ["a"]}, ], f) self._save_state({"tasks": {}, "automations": []}) def _run_turn(srv, state, task, prompt, model, effort, sandbox, **kw): task["status"] = "completed" return {"status": "completed", "text": "ok"} code, out = self._run( FakeServer(), "parallel", "--jobs", jobs_path, run_task_turn_with_retry=_run_turn) self.assertEqual(code, 0) state = self._load_state() self.assertEqual(state["tasks"]["a"]["status"], "completed") self.assertEqual(state["tasks"]["b"]["status"], "completed") # 依赖分支派发后 b 的 worktree 与 a 的分支有血缘： # b 的 branch 应存在且不同于 a。 self.assertNotEqual(state["tasks"]["a"]["branch"], state["tasks"]["b"]["branch"]) # 清理 parallel 建的 worktree（HERE/work 下）。 for name in ("a", "b"): wt = state["tasks"][name]["cwd"] subprocess.run(["git", "-C", repo, "worktree", "remove", "--force", wt], capture_output=True) subprocess.run(["git", "-C", repo, "branch", "-D", state["tasks"][name]["branch"]], capture_output=True) def test_automations_add_list_and_run_due(self): self._save_state({"tasks": {}, "automations": []}) code, out = self._run(FakeServer(), "automations", "--add", "--name", "daily", "--task", "巡检") self.assertEqual(code, 0) self.assertIn("automation added", out) code, out = self._run(FakeServer(), "automations") self.assertIn("daily", out) # run-due：一条未到期跳过、一条到期跑（dispatch/turn 替身）。 state = self._load_state() state["automations"] = [ {"name": "soon", "task": "x", "repo": None, "interval": 86400, "last_run": time.time()}, {"name": "due", "task": "巡检", "repo": None, "interval": 60, "last_run": 0}, ] self._save_state(state) def _dispatch(srv, state, name, prompt, repo, model, effort, sandbox, approval_policy, **kw): task = {"name": name, "thread_id": "th-1", "cwd": "/tmp", "status": "running", "prompt": prompt} state["tasks"][name] = task return task code, out = self._run( FakeServer(), "run-due", dispatch=_dispatch, run_task_turn=lambda *a, **k: {"status": "failed", "text": "bad"}) self.assertEqual(code, 0) self.assertIn("automation due ->", out) state = self._load_state() self.assertGreater(state["automations"][1]["last_run"], 0) if __name__ == "__main__": unittest.main()