Secure, Fast, and Extensible Sandbox runtime for AI agents.
test(egress): make resolver harness fail on handler errors, one connection per request
高然1f761e04bf84
diff --git a/components/egress/tests/resolver/resolver.py b/components/egress/tests/resolver/resolver.pyindex bd0f12af9..2e684d330 100644--- a/components/egress/tests/resolver/resolver.py+++ b/components/egress/tests/resolver/resolver.py@@ -85,6 +85,7 @@ import sslimport sysimport threadingimport time+import tracebackfrom typing import AnyMAX_REQUEST_BYTES = 64 * 1024@@ -245,7 +246,10 @@ class _UnixHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):self.server_port = 0def handle_error(self, _request: object, _address: object) -> None:- pass+ # Record instead of swallow: tests assert this list stays empty, so+ # handler bugs surface as server-side failures instead of mystery+ # client errors such as BrokenPipeError on a socket we closed.+ self.exceptions.append(traceback.format_exc())class _TCPHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):@@ -253,7 +257,7 @@ class _TCPHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):allow_reuse_address = Truedef handle_error(self, _request: object, _address: object) -> None:- pass+ self.exceptions.append(traceback.format_exc())class _Handler(http.server.BaseHTTPRequestHandler):@@ -393,6 +397,7 @@ def build_server(server.transport = transportserver.expected_token = expected_tokenserver.options = options+ server.exceptions = []server.request_timeout = max(30.0, options.delay / 1000.0 * 2 + 5.0)return serverdiff --git a/components/egress/tests/resolver/test_resolver.py b/components/egress/tests/resolver/test_resolver.pyindex 34ff83e7b..87e8509f1 100644--- a/components/egress/tests/resolver/test_resolver.py+++ b/components/egress/tests/resolver/test_resolver.py@@ -95,10 +95,21 @@ class _UnixConnection(http.client.HTTPConnection):class _ResolverProcess:- """Run one resolver server instance in a background thread."""+ """Run one resolver server instance in a background thread.- def __init__(self, server: Any) -> None:+ Every response carries ``Connection: close`` (mirroring the revision IPC+ discipline: one request per connection), so clients must open a fresh+ connection per request; reusing one trips over the server-side close.+ Handler-side exceptions are recorded on the server instead of being+ swallowed and are asserted here unless they belong to the expected+ client-abort class (``allow_client_aborts``, e.g. the delay test).+ """++ CLIENT_ABORT_ERRORS = ("BrokenPipeError", "ConnectionResetError")++ def __init__(self, server: Any, *, allow_client_aborts: bool = False) -> None:self.server = server+ self.allow_client_aborts = allow_client_abortsself._thread = threading.Thread(target=server.serve_forever, daemon=True)def __enter__(self) -> "_ResolverProcess":@@ -108,6 +119,17 @@ class _ResolverProcess:def __exit__(self, *_exc: object) -> None:self.server.shutdown()self.server.server_close()+ records = list(getattr(self.server, "exceptions", []))+ if self.allow_client_aborts:+ records = [+ record+ for record in records+ if not any(name in record for name in self.CLIENT_ABORT_ERRORS)+ ]+ if records:+ raise AssertionError(+ "resolver handler raised unexpectedly:\n" + "\n".join(records)+ )def build_uds_server(socket_path: str, argv: list[str] | None = None) -> Any:@@ -141,10 +163,10 @@ class ResolverUDSTest(unittest.TestCase):self.socket_path = os.path.join(self._tmp.name, "resolver.sock")def post(self, body: bytes, headers: dict[str, str] | None = None,- timeout: float = 10) -> tuple[int, bytes]:+ timeout: float = 10, path: str = RESOLVE_PATH) -> tuple[int, bytes]:connection = _UnixConnection(self.socket_path, timeout=timeout)try:- connection.request("POST", RESOLVE_PATH, body=body, headers={+ connection.request("POST", path, body=body, headers={"Content-Type": "application/json",**(headers or {}),})@@ -196,17 +218,13 @@ class ResolverUDSTest(unittest.TestCase):)def test_fixed_service_path_rejects_other_paths_with_404(self) -> None:- connection = _UnixConnection(self.socket_path)+ # One fresh connection per request: the resolver replies with+ # ``Connection: close`` and closes the socket, so reusing a+ # connection across requests races the server-side close.with _ResolverProcess(build_uds_server(self.socket_path)):for path in ("/", "/resolve/", "/v1/resolve"):- connection.request("POST", path, body=dumps(VALID_REQUEST), headers={- "Content-Type": "application/json",- })- response = connection.getresponse()- status = response.status- response.read()+ status, _ = self.post(dumps(VALID_REQUEST), path=path)self.assertEqual(404, status, path)- connection.close()def test_uds_mode_ignores_host_header(self) -> None:connection = _UnixConnection(self.socket_path)@@ -415,7 +433,10 @@ class ResolverFaultInjectionTest(unittest.TestCase):def test_delay_exceeds_client_timeout(self) -> None:server = build_uds_server(self.socket_path, ["--delay", "1000"])- with _ResolverProcess(server):+ # The client aborts at 0.2s while the handler is still sleeping, so+ # the handler's eventual write raises a client-abort error that the+ # harness tolerates; anything else still fails the test.+ with _ResolverProcess(server, allow_client_aborts=True):started = time.monotonic()with self.assertRaises((TimeoutError, OSError)):self._post(timeout=0.2)