115 lines
4.4 KiB
Python
115 lines
4.4 KiB
Python
from __future__ import annotations
|
|
|
|
import argparse
|
|
import io
|
|
import json
|
|
import os
|
|
import tempfile
|
|
import unittest
|
|
from contextlib import redirect_stderr, redirect_stdout
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
from agent_integration import __main__ as cli
|
|
from agent_integration.sessions import SQLiteSessionStore
|
|
|
|
|
|
class AgentCLITests(unittest.TestCase):
|
|
def test_metadata_requires_json_object(self):
|
|
with self.assertRaises(argparse.ArgumentTypeError):
|
|
cli.parse_metadata('["not", "an", "object"]')
|
|
|
|
def test_doctor_reports_missing_key_without_network(self):
|
|
with tempfile.TemporaryDirectory() as temp_dir:
|
|
stdout = io.StringIO()
|
|
stderr = io.StringIO()
|
|
env = {"DEERFLOW_SESSION_DB": str(Path(temp_dir) / "sessions.sqlite3")}
|
|
with patch.dict(os.environ, env, clear=True), redirect_stdout(stdout), redirect_stderr(stderr):
|
|
exit_code = cli.main(["doctor"])
|
|
|
|
report = json.loads(stdout.getvalue())
|
|
self.assertEqual(exit_code, 2)
|
|
self.assertEqual(report["status"], "missing_api_key")
|
|
self.assertFalse(report["api_key_configured"])
|
|
self.assertFalse(report["network_checked"])
|
|
self.assertEqual(stderr.getvalue(), "")
|
|
|
|
def test_doctor_never_prints_configured_secret(self):
|
|
secret = "df_open_cli_secret"
|
|
stdout = io.StringIO()
|
|
with patch.dict(os.environ, {"DEERFLOW_OPEN_API_KEY": secret}, clear=True), redirect_stdout(stdout):
|
|
exit_code = cli.main(["doctor"])
|
|
|
|
self.assertEqual(exit_code, 0)
|
|
self.assertTrue(json.loads(stdout.getvalue())["api_key_configured"])
|
|
self.assertNotIn(secret, stdout.getvalue())
|
|
|
|
def test_show_session_does_not_require_api_key(self):
|
|
with tempfile.TemporaryDirectory() as temp_dir:
|
|
db_path = Path(temp_dir) / "sessions.sqlite3"
|
|
with SQLiteSessionStore(db_path) as store:
|
|
store.put(
|
|
conversation_id="conversation-001",
|
|
session_id="open_sess_123",
|
|
external_subject_id="customer-001",
|
|
metadata={"source": "unittest"},
|
|
)
|
|
stdout = io.StringIO()
|
|
with patch.dict(os.environ, {}, clear=True), redirect_stdout(stdout):
|
|
exit_code = cli.main(
|
|
[
|
|
"--session-db",
|
|
str(db_path),
|
|
"show-session",
|
|
"--conversation-id",
|
|
"conversation-001",
|
|
]
|
|
)
|
|
|
|
self.assertEqual(exit_code, 0)
|
|
self.assertEqual(json.loads(stdout.getvalue())["session_id"], "open_sess_123")
|
|
|
|
def test_poll_timeout_is_bounded(self):
|
|
class AlwaysRunningService:
|
|
def get_run(self, conversation_id, run_id):
|
|
return {"run_id": run_id, "status": "running"}
|
|
|
|
with patch("agent_integration.__main__.time.monotonic", side_effect=[0.0, 2.0]):
|
|
with redirect_stdout(io.StringIO()), self.assertRaises(TimeoutError):
|
|
cli._poll_run( # pylint: disable=protected-access
|
|
AlwaysRunningService(), # type: ignore[arg-type]
|
|
"conversation-001",
|
|
"run-001",
|
|
poll_interval=0.1,
|
|
poll_timeout=1.0,
|
|
)
|
|
|
|
def test_successful_poll_without_final_content_emits_warning(self):
|
|
class SuccessfulService:
|
|
def get_run(self, conversation_id, run_id):
|
|
return {
|
|
"run_id": run_id,
|
|
"status": "success",
|
|
"final_content": None,
|
|
}
|
|
|
|
stdout = io.StringIO()
|
|
stderr = io.StringIO()
|
|
with redirect_stdout(stdout), redirect_stderr(stderr):
|
|
cli._poll_run( # pylint: disable=protected-access
|
|
SuccessfulService(), # type: ignore[arg-type]
|
|
"conversation-001",
|
|
"run-001",
|
|
poll_interval=0.1,
|
|
poll_timeout=1.0,
|
|
)
|
|
|
|
self.assertEqual(json.loads(stdout.getvalue())["status"], "success")
|
|
warning = json.loads(stderr.getvalue())
|
|
self.assertEqual(warning["warning"], "run_result_unavailable")
|
|
self.assertEqual(warning["run_id"], "run-001")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|