Task 007 implement agent job queue and fake runner path

2026-05-21 19:28:37 +03:00
parent ff1a2f78c0
commit 4fd837349f
12 changed files with 956 additions and 7 deletions
@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Any
+
+from fastapi.testclient import TestClient
+
+
+BACKEND_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(BACKEND_ROOT))
+
+from src.application.seed_data import seed_reference_data  # noqa: E402
+from src.infrastructure.repositories import open_backend_repository  # noqa: E402
+from src.presentation.dependencies import get_repository  # noqa: E402
+from src.presentation.main import app  # noqa: E402
+
+
+DEMO_ADMIN_EMAIL = "admin@example.com"
+DEMO_USER_EMAIL_HEADER = "X-Demo-User-Email"
+
+
+class AgentJobQueuePublicApiTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp_dir = tempfile.TemporaryDirectory()
+        self.workspace_root = Path(self.tmp_dir.name) / "runner-workspaces"
+        dsn = f"sqlite:///{Path(self.tmp_dir.name) / 'agent-jobs.db'}"
+        self.repository = open_backend_repository(dsn)
+        self.repository.setup()
+        seed_reference_data(self.repository)
+        app.dependency_overrides[get_repository] = lambda: self.repository
+        self.client = TestClient(app)
+
+    def tearDown(self) -> None:
+        app.dependency_overrides.clear()
+        self.tmp_dir.cleanup()
+
+    def test_admin_enqueues_and_fake_runner_completes_test_codex_job(self) -> None:
+        create_response = self.client.post(
+            "/api/agent-jobs/test-codex",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+
+        self.assertEqual(201, create_response.status_code, create_response.text)
+        created = create_response.json()["job"]
+        self.assertEqual("TEST_CODEX", created["job_type"])
+        self.assertEqual("QUEUED", created["status"])
+        self.assertEqual(1, created["attempt"])
+
+        self._run_fake_runner_once()
+
+        get_response = self.client.get(
+            f"/api/agent-jobs/{created['id']}",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+        list_response = self.client.get(
+            "/api/agent-jobs",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+
+        self.assertEqual(200, get_response.status_code, get_response.text)
+        completed = get_response.json()["job"]
+        self.assertEqual("SUCCEEDED", completed["status"])
+        self.assertTrue(completed["workspace_path"])
+        self.assertIn("fake Codex runner completed", completed["stdout"])
+        self.assertEqual("", completed["stderr"])
+        self.assertEqual(0, completed["exit_code"])
+        self.assertGreaterEqual(completed["duration_ms"], 0)
+        self.assertEqual([{"path": "outputs/result.json", "content_hash": None}], completed["output_files"])
+
+        self.assertEqual(200, list_response.status_code, list_response.text)
+        self.assertIn(
+            created["id"],
+            [job["id"] for job in list_response.json()["jobs"]],
+        )
+        self.assertTrue((Path(completed["workspace_path"]) / "outputs" / "result.json").is_file())
+
+    def test_retry_creates_traceable_child_attempt(self) -> None:
+        failed = self.client.post(
+            "/api/agent-jobs/test-codex",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+            json={"fake_result": "invalid_schema"},
+        ).json()["job"]
+
+        self._run_fake_runner_once()
+
+        failed_response = self.client.get(
+            f"/api/agent-jobs/{failed['id']}",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+        self.assertEqual("FAILED", failed_response.json()["job"]["status"])
+        self.assertEqual(
+            "FAILED_SCHEMA_VALIDATION",
+            failed_response.json()["job"]["error_category"],
+        )
+
+        retry_response = self.client.post(
+            f"/api/agent-jobs/{failed['id']}/retry",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+
+        self.assertEqual(201, retry_response.status_code, retry_response.text)
+        retry = retry_response.json()["job"]
+        self.assertEqual("QUEUED", retry["status"])
+        self.assertEqual(failed["id"], retry["parent_job_id"])
+        self.assertEqual(2, retry["attempt"])
+
+    def test_cancelled_job_is_not_claimed_or_completed_by_runner(self) -> None:
+        created = self.client.post(
+            "/api/agent-jobs/test-codex",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        ).json()["job"]
+
+        cancel_response = self.client.post(
+            f"/api/agent-jobs/{created['id']}/cancel",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+        self.assertEqual(200, cancel_response.status_code, cancel_response.text)
+        self.assertEqual("CANCELLED", cancel_response.json()["job"]["status"])
+
+        self._run_fake_runner_once()
+
+        get_response = self.client.get(
+            f"/api/agent-jobs/{created['id']}",
+            headers={DEMO_USER_EMAIL_HEADER: DEMO_ADMIN_EMAIL},
+        )
+        job = get_response.json()["job"]
+        self.assertEqual("CANCELLED", job["status"])
+        self.assertEqual([], job["output_files"])
+        self.assertIsNone(job["workspace_path"])
+
+    def _run_fake_runner_once(self) -> None:
+        claim_response = self.client.post("/internal/agent-jobs/claim")
+        if claim_response.status_code == 204:
+            return
+
+        self.assertEqual(200, claim_response.status_code, claim_response.text)
+        job = claim_response.json()["job"]
+        workspace_path = self._write_fake_workspace(job)
+        fake_output: dict[str, Any]
+        if job["agent_profile"] == "fake-invalid-schema":
+            fake_output = {"status": "NOT_A_STATUS"}
+        else:
+            fake_output = {
+                "status": "SUCCEEDED",
+                "output_files": [{"path": "outputs/result.json"}],
+                "payload": {"job_id": job["id"], "mode": "fake"},
+            }
+
+        complete_response = self.client.post(
+            f"/internal/agent-jobs/{job['id']}/complete",
+            json={
+                "workspace_path": str(workspace_path),
+                "stdout": "fake Codex runner completed\n",
+                "stderr": "",
+                "exit_code": 0,
+                "duration_ms": 1,
+                "output": fake_output,
+            },
+        )
+        self.assertEqual(200, complete_response.status_code, complete_response.text)
+
+    def _write_fake_workspace(self, job: dict[str, Any]) -> Path:
+        workspace_path = self.workspace_root / job["id"]
+        if workspace_path.exists():
+            shutil.rmtree(workspace_path)
+        (workspace_path / "inputs").mkdir(parents=True)
+        (workspace_path / "logs").mkdir()
+        (workspace_path / "outputs").mkdir()
+        (workspace_path / "inputs" / "job.json").write_text(str(job), encoding="utf-8")
+        (workspace_path / "logs" / "stdout.log").write_text(
+            "fake Codex runner completed\n",
+            encoding="utf-8",
+        )
+        (workspace_path / "logs" / "stderr.log").write_text("", encoding="utf-8")
+        (workspace_path / "outputs" / "result.json").write_text(
+            '{"status":"ok"}\n',
+            encoding="utf-8",
+        )
+        return workspace_path
+
+
+if __name__ == "__main__":
+    unittest.main()