host
4cd9b5eaa4
新增 run_tests.py：三套件统一入口，只加仓库根（deploy 套件 再加 deploy/ 目录在根之前），各套件走独立子进程；verify 作 业改走运行器，coverage 作业因子进程测不到覆盖率保持原 discover 命令。tests/ 13 个文件的 sys.path 前置 import 全部 改回正常 import（含 test_host_trace 的 try/except 回落）； deploy 的 deploy 目录插入与 verify-multiuser 的 spec 加载按 陷阱 2 如实保留（仅删 verify-multiuser 冗余的根插入）。 .coveragerc omit 加 */run_tests.py，使新运行器文件不计入 生产覆盖率。门槛未动（仍 75%），未补新测试。
289 lines
11 KiB
Python
289 lines
11 KiB
Python
"""client.py 单测（CI 第二阶段覆盖率：基线 0%）。
|
|
|
|
不跑真实 codex 二进制：AppServer 只跟子进程的 stdin/stdout
|
|
说话，本文件用真实 os.pipe 作 stdout 通道（select + os.read
|
|
原样走）、BytesIO 作 stdin——JSON-RPC 成帧、审批自动回包、
|
|
wait_for 事件分发、initialize/close 都是被测代码的真实逻辑，
|
|
只把“子进程是 codex”换成管道。main() 的分支用一个记录型
|
|
FakeAppServer 测（断言它发出的请求参数与分支选择）。
|
|
"""
|
|
|
|
import io
|
|
import json
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import types
|
|
import unittest
|
|
from contextlib import redirect_stdout, redirect_stderr
|
|
from unittest import mock
|
|
import client as client_mod
|
|
|
|
|
|
class FakeProc:
|
|
"""Popen 替身：stdout 是真实 pipe（可 select/os.read），
|
|
stdin 是 BytesIO（可断言发出的每一行）。"""
|
|
|
|
def __init__(self, chunks, wait_exc=None):
|
|
self.r, self.w = os.pipe()
|
|
for chunk in chunks:
|
|
os.write(self.w, chunk)
|
|
os.close(self.w)
|
|
self.stdin = io.BytesIO()
|
|
self.stdout = types.SimpleNamespace(fileno=lambda: self.r)
|
|
self._wait_exc = wait_exc
|
|
self.waited = False
|
|
self.killed = False
|
|
|
|
def poll(self):
|
|
return None
|
|
|
|
def wait(self, timeout=None):
|
|
self.waited = True
|
|
if self._wait_exc is not None:
|
|
raise self._wait_exc
|
|
return 0
|
|
|
|
def kill(self):
|
|
self.killed = True
|
|
|
|
def close_fds(self):
|
|
try:
|
|
os.close(self.r)
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
def _line(obj):
|
|
return (json.dumps(obj) + "\n").encode()
|
|
|
|
|
|
class AppServerPipeTest(unittest.TestCase):
|
|
def _server(self, chunks, codex_home=None, wait_exc=None):
|
|
proc = FakeProc(chunks, wait_exc=wait_exc)
|
|
self.addCleanup(proc.close_fds)
|
|
with mock.patch.object(client_mod.subprocess, "Popen",
|
|
return_value=proc):
|
|
srv = client_mod.AppServer(codex_home=codex_home)
|
|
srv._proc = proc
|
|
return srv, proc
|
|
|
|
def test_request_and_notify_framing(self):
|
|
srv, proc = self._server([])
|
|
rid = srv.request("thread/list", {"a": 1})
|
|
self.assertEqual(rid, 1)
|
|
srv.notify("initialized", {})
|
|
self.assertEqual(srv.next_id, 2)
|
|
lines = proc.stdin.getvalue().decode().splitlines()
|
|
self.assertEqual(json.loads(lines[0]),
|
|
{"jsonrpc": "2.0", "id": 1, "method": "thread/list",
|
|
"params": {"a": 1}})
|
|
self.assertEqual(json.loads(lines[1]),
|
|
{"jsonrpc": "2.0", "method": "initialized",
|
|
"params": {}})
|
|
|
|
def test_read_msg_answers_approval_then_returns_response(self):
|
|
chunks = [_line({"jsonrpc": "2.0", "id": 9,
|
|
"method": "approval/request",
|
|
"params": {"x": 1}}),
|
|
_line({"jsonrpc": "2.0", "id": 1, "result": {"ok": True}})]
|
|
srv, proc = self._server(chunks)
|
|
srv.approval_policy = "deny"
|
|
msg = srv._read_msg(5)
|
|
self.assertEqual(msg, {"jsonrpc": "2.0", "id": 1,
|
|
"result": {"ok": True}})
|
|
sent = proc.stdin.getvalue().decode().splitlines()
|
|
self.assertEqual(json.loads(sent[0]),
|
|
{"jsonrpc": "2.0", "id": 9,
|
|
"result": {"decision": "deny"}})
|
|
|
|
def test_read_msg_approval_auto(self):
|
|
chunks = [_line({"jsonrpc": "2.0", "id": 7,
|
|
"method": "permission/request", "params": {}}),
|
|
_line({"jsonrpc": "2.0", "id": 1, "result": {}})]
|
|
srv, proc = self._server(chunks)
|
|
srv.approval_policy = "auto"
|
|
with redirect_stderr(io.StringIO()):
|
|
msg = srv._read_msg(5)
|
|
self.assertEqual(msg["id"], 1)
|
|
sent = proc.stdin.getvalue().decode().splitlines()
|
|
self.assertEqual(json.loads(sent[0])["result"],
|
|
{"decision": "approve"})
|
|
|
|
def test_wait_for_dispatches_events(self):
|
|
chunks = [_line({"jsonrpc": "2.0", "method": "agent/message/delta",
|
|
"params": {"item": {"type": "agentMessage",
|
|
"text": "hi"}}}),
|
|
_line({"jsonrpc": "2.0", "id": 3, "result": {"done": 1}})]
|
|
srv, _ = self._server(chunks)
|
|
seen = []
|
|
msg = srv.wait_for(3, timeout=5, on_event=seen.append)
|
|
self.assertEqual(msg["result"], {"done": 1})
|
|
self.assertEqual(len(seen), 1)
|
|
self.assertEqual(seen[0]["method"], "agent/message/delta")
|
|
|
|
def test_wait_for_eof_returns_none(self):
|
|
srv, _ = self._server([])
|
|
self.assertIsNone(srv.wait_for(1, timeout=5))
|
|
|
|
def test_initialize_success_and_error(self):
|
|
chunks = [_line({"jsonrpc": "2.0", "id": 1,
|
|
"result": {"codexHome": "/tmp/ch",
|
|
"platformOs": "linux"}})]
|
|
srv, proc = self._server(chunks)
|
|
info = srv.initialize()
|
|
self.assertEqual(info["platformOs"], "linux")
|
|
sent = proc.stdin.getvalue().decode().splitlines()
|
|
self.assertEqual(json.loads(sent[0])["method"], "initialize")
|
|
self.assertEqual(json.loads(sent[1])["method"], "initialized")
|
|
|
|
srv2, _ = self._server(
|
|
[_line({"jsonrpc": "2.0", "id": 1,
|
|
"error": {"code": -1, "message": "boom"}})])
|
|
with self.assertRaises(RuntimeError):
|
|
srv2.initialize()
|
|
|
|
def test_codex_home_created(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
home = os.path.join(tmp, "new-home")
|
|
srv, proc = self._server([], codex_home=home)
|
|
self.assertTrue(os.path.isdir(home))
|
|
self.assertEqual(proc.stdin.getvalue(), b"")
|
|
|
|
def test_close_waits_and_kills_on_timeout(self):
|
|
srv, proc = self._server([])
|
|
srv.close()
|
|
self.assertTrue(proc.waited)
|
|
self.assertFalse(proc.killed)
|
|
import subprocess as _sp
|
|
srv2, proc2 = self._server(
|
|
[], wait_exc=_sp.TimeoutExpired("codex", 5))
|
|
srv2.close()
|
|
self.assertTrue(proc2.killed)
|
|
|
|
|
|
class HandleEventTest(unittest.TestCase):
|
|
def test_agent_delta_printed(self):
|
|
out = io.StringIO()
|
|
with redirect_stdout(out):
|
|
client_mod.handle_event(
|
|
{"method": "agent/message/delta",
|
|
"params": {"item": {"type": "agentMessage",
|
|
"text": "hello"}}})
|
|
self.assertEqual(out.getvalue(), "hello")
|
|
|
|
def test_turn_completed_and_error_paths(self):
|
|
out, err = io.StringIO(), io.StringIO()
|
|
with redirect_stdout(out), redirect_stderr(err):
|
|
client_mod.handle_event(
|
|
{"method": "turn/completed",
|
|
"params": {"status": "completed"}})
|
|
# 首分支元组外、含 started 的方法走 stderr 分支。
|
|
client_mod.handle_event(
|
|
{"method": "session/started", "params": {}})
|
|
client_mod.handle_event(
|
|
{"method": "something", "params": {"error": "x"}})
|
|
self.assertIn("[turn/completed]", out.getvalue())
|
|
self.assertIn("[session/started]", err.getvalue())
|
|
self.assertIn("[something]", err.getvalue())
|
|
|
|
|
|
class FakeAppServer:
|
|
def __init__(self, codex_home=None, extra_args=None):
|
|
self.codex_home = codex_home
|
|
self.approval_policy = "deny"
|
|
self.requests = []
|
|
self.notifies = []
|
|
self.responses = {}
|
|
self.read_msgs = []
|
|
self.closed = False
|
|
|
|
def request(self, method, params=None):
|
|
rid = len(self.requests) + 1
|
|
self.requests.append((method, params))
|
|
return rid
|
|
|
|
def notify(self, method, params=None):
|
|
self.notifies.append((method, params))
|
|
|
|
def wait_for(self, rid, timeout=60, on_event=None):
|
|
return self.responses.get(rid)
|
|
|
|
def _read_msg(self, timeout):
|
|
return self.read_msgs.pop(0) if self.read_msgs else None
|
|
|
|
def initialize(self):
|
|
return {"codexHome": "/tmp/ch", "platformOs": "linux"}
|
|
|
|
def close(self):
|
|
self.closed = True
|
|
|
|
|
|
class ClientMainTest(unittest.TestCase):
|
|
def _run(self, argv, setup):
|
|
fake = FakeAppServer()
|
|
setup(fake)
|
|
err = io.StringIO()
|
|
with mock.patch.object(client_mod, "AppServer",
|
|
return_value=fake), \
|
|
mock.patch.object(sys, "argv", argv), \
|
|
redirect_stderr(err):
|
|
out = io.StringIO()
|
|
with redirect_stdout(out):
|
|
client_mod.main()
|
|
return fake, out.getvalue(), err.getvalue()
|
|
|
|
def test_list_threads(self):
|
|
def setup(fake):
|
|
fake.responses[1] = {"result": {"threads": []}}
|
|
fake, out, _ = self._run(
|
|
["client.py", "--list-threads", "--cwd", "/tmp"],
|
|
setup)
|
|
self.assertEqual(fake.requests[0][0], "thread/list")
|
|
self.assertIn("threads", out)
|
|
self.assertTrue(fake.closed)
|
|
|
|
def test_start_and_turn_completed(self):
|
|
def setup(fake):
|
|
fake.responses[1] = {"result": {"thread": {"id": "th-9"},
|
|
"model": "m"}}
|
|
fake.read_msgs.append(
|
|
{"method": "turn/completed", "params": {"ok": True}})
|
|
fake, out, _ = self._run(
|
|
["client.py", "--prompt", "fix it", "--cwd", "/tmp",
|
|
"--model", "gpt-x", "--sandbox", "read-only",
|
|
"--approval-policy", "never"],
|
|
setup)
|
|
start = fake.requests[0]
|
|
self.assertEqual(start[0], "thread/start")
|
|
self.assertEqual(start[1]["approvalPolicy"], "never")
|
|
self.assertEqual(start[1]["sandbox"], "read-only")
|
|
self.assertEqual(start[1]["model"], "gpt-x")
|
|
turn = fake.requests[1]
|
|
self.assertEqual(turn[0], "turn/start")
|
|
self.assertEqual(turn[1]["threadId"], "th-9")
|
|
self.assertEqual(turn[1]["input"][0]["text"], "fix it")
|
|
self.assertIn("[done]", out)
|
|
self.assertTrue(fake.closed)
|
|
|
|
def test_resume_failure_prints_and_returns(self):
|
|
def setup(fake):
|
|
fake.responses[1] = {"error": {"message": "gone"}}
|
|
fake, out, err = self._run(
|
|
["client.py", "--thread-id", "th-1", "--cwd", "/tmp"],
|
|
setup)
|
|
self.assertEqual(fake.requests[0][0], "thread/resume")
|
|
self.assertIn("thread/resume", err)
|
|
self.assertTrue(fake.closed)
|
|
|
|
def test_no_prompt_prints_thread_id(self):
|
|
def setup(fake):
|
|
fake.responses[1] = {"result": {"thread": {"id": "th-2"}}}
|
|
_, out, _ = self._run(
|
|
["client.py", "--cwd", "/tmp"], setup)
|
|
self.assertIn("thread_id=th-2", out)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|