fix(cli): type the job reporter as a protocol so the suite type-checks

CI runs mypy over tests as well as src, and these tests were red: the recording
fakes they pass to JobRegistry.start and JobLogTailer are not HandlerCallbacks.

Neither collaborator wants the socket transport -- they want somewhere to send a
result and somewhere to send logs -- so say that: JobReporter is a Protocol with
those two methods, and HandlerCallback satisfies it structurally. The fakes then
type-check as themselves rather than needing a cast at every call site.

Worth noting the protocol immediately found a real gap: test_server_async's
FakeCallback had no post_logs at all, so the tailer's calls into it were only
ever working by accident of it never being exercised there.

The rest is local: cast the _FakeRequest stand-ins to web.Request at the two
handle_start call sites, and narrow web.Response.text (str | None) before
json.loads and `in`.

Author: robert-ursu

packages/uipath/src/uipath/_cli/_server_jobs.py

@@ -16,7 +16,7 @@
 import os
 import re
 import sys
-from typing import Any
+from typing import Any, Protocol
 
 from aiohttp import ClientSession, ClientTimeout, UnixConnector
 
@@ -90,6 +90,18 @@ class _PostOutcome(enum.Enum):
     UNREACHABLE = "unreachable"  # transport failure or 5xx — worth retrying
 
 
+class JobReporter(Protocol):
+    """Where a job's logs and outcome go.
+
+    All the registry and the tailer need. Kept separate from HandlerCallback so a
+    reporter can be substituted without inheriting the socket transport.
+    """
+
+    async def post_result(self, job_key: str, payload: dict[str, Any]) -> bool: ...
+
+    async def post_logs(self, job_key: str, lines: list[dict[str, Any]]) -> bool: ...
+
+
 class HandlerCallback:
     """Posts job lifecycle events to the caller's Unix-socket HTTP API."""
 
@@ -200,7 +212,7 @@ class JobLogTailer:
     still produced exactly as before, we just also forward it.
     """
 
-    def __init__(self, job_key: str, path: str, callback: "HandlerCallback") -> None:
+    def __init__(self, job_key: str, path: str, callback: "JobReporter") -> None:
         self.job_key = job_key
         self.path = path
         self.callback = callback
@@ -307,7 +319,7 @@ def start(
         args: list[str],
         env_vars: dict[str, str],
         working_dir: str | None,
-        callback: HandlerCallback,
+        callback: JobReporter,
     ) -> bool:
         """Register and schedule a job. False if one is already in flight for this key."""
         if self.is_active(job_key):
@@ -330,7 +342,7 @@ async def _run(
         args: list[str],
         env_vars: dict[str, str],
         working_dir: str | None,
-        callback: HandlerCallback,
+        callback: JobReporter,
     ) -> None:
         tailer: JobLogTailer | None = None
         tail_task: "asyncio.Task[None] | None" = None

packages/uipath/tests/cli/test_server_async.py

@@ -8,10 +8,11 @@
 import asyncio
 import json
 import os
-from typing import Any
+from typing import Any, cast
 
 import click
 import pytest
+from aiohttp import web
 
 from uipath._cli import _server_core, cli_server, cli_server_ipc
 from uipath._cli._server_core import (
@@ -44,6 +45,9 @@ async def post_result(self, job_key: str, payload: dict[str, Any]) -> bool:
         self.done.set()
         return True
 
+    async def post_logs(self, job_key: str, lines: list[dict[str, Any]]) -> bool:
+        return True
+
 
 def _write_config(tmp_path, runtime: dict[str, Any] | None) -> str:
     config = {"runtime": runtime} if runtime is not None else {}
@@ -261,6 +265,16 @@ async def json(self) -> dict[str, Any]:
         return self._payload
 
 
+def _fake_request(job_key: str, payload: dict[str, Any]) -> web.Request:
+    """handle_start only touches match_info and json(); the cast keeps mypy honest."""
+    return cast(web.Request, _FakeRequest(job_key, payload))
+
+
+def _body(response: web.Response) -> dict[str, Any]:
+    assert response.text is not None
+    return cast("dict[str, Any]", json.loads(response.text))
+
+
 class _RecordingRegistry:
     def __init__(self, accept: bool = True) -> None:
         self.accept = accept
@@ -276,14 +290,14 @@ async def test_http_start_with_callback_returns_accepted(monkeypatch):
     monkeypatch.setattr(cli_server, "get_registry", lambda: registry)
 
     response = await cli_server.handle_start(
-        _FakeRequest(
+        _fake_request(
             "job-1",
             {"command": "run", "resultCallbackSocket": "/tmp/ack.sock"},
         )
     )
 
     assert response.status == 202
-    body = json.loads(response.text)
+    body = _body(response)
     assert body["disposition"] == "accepted"
     assert body["contractVersion"] == CONTRACT_VERSION
     assert registry.started == ["job-1"]
@@ -295,13 +309,13 @@ async def test_http_start_duplicate_is_409(monkeypatch):
     )
 
     response = await cli_server.handle_start(
-        _FakeRequest(
+        _fake_request(
             "job-1", {"command": "run", "resultCallbackSocket": "/tmp/ack.sock"}
         )
     )
 
     assert response.status == 409
-    assert json.loads(response.text)["success"] is False
+    assert _body(response)["success"] is False
 
 
 async def test_http_start_without_callback_stays_synchronous(monkeypatch):
@@ -319,11 +333,11 @@ async def _fake_isolated(cmd, args, env_vars, working_dir):
         lambda: pytest.fail("registry must not be used without a callback socket"),
     )
 
-    response = await cli_server.handle_start(_FakeRequest("job-1", {"command": "run"}))
+    response = await cli_server.handle_start(_fake_request("job-1", {"command": "run"}))
 
     assert called.get("ran") is True
     assert response.status == 200
-    body = json.loads(response.text)
+    body = _body(response)
     assert body["success"] is True
     assert "disposition" not in body
 
@@ -362,7 +376,7 @@ async def test_ipc_start_duplicate_reports_failure(monkeypatch):
 
     assert result.ExitCode == 1
     assert result.Disposition is None
-    assert "already in flight" in result.Error
+    assert "already in flight" in (result.Error or "")
 
 
 async def test_ipc_start_without_callback_stays_synchronous(monkeypatch):

packages/uipath/tests/cli/test_server_result.py

@@ -7,7 +7,7 @@
 rather than a stub, because it is the whole reason the exit code can be wrong.
 """
 
-from typing import Any
+from typing import Any, cast
 
 import click
 import pytest
@@ -132,7 +132,8 @@ async def _fake_isolated(cmd, args, env_vars, working_dir):
         return command_result
 
     monkeypatch.setattr(cli_server, "_run_command_isolated", _fake_isolated)
-    return await cli_server.handle_start(_FakeRequest("job-1", {"command": "run"}))
+    request = cast(web.Request, _FakeRequest("job-1", {"command": "run"}))
+    return await cli_server.handle_start(request)
 
 
 async def test_success_body_carries_exit_code(monkeypatch):
@@ -157,7 +158,7 @@ async def test_failure_body_is_200_but_says_so_and_carries_exit_code(monkeypatch
     )
 
     assert response.status == 200
-    body = response.text
+    body = response.text or ""
     assert '"success": false' in body
     assert '"exitCode": 1' in body
     assert "Exit code: 1" in body