The Full Request/Response textarea was showing literal `\n` inside string values. Changed `_pretty_json(raw, replace_nl=False)` to `_pretty_json(raw)` in the payload endpoint so escaped newlines are rendered as actual line breaks for readability. Test updated to verify visual content instead of re-parsing the textarea output as JSON (which is no longer valid after newline expansion, and intentionally so).
225 lines
9 KiB
Python
225 lines
9 KiB
Python
"""Tests for lazy-loaded full request and response payloads."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import html
|
|
import json
|
|
import os
|
|
import re
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import create_autospec, patch
|
|
|
|
from starlette.requests import Request
|
|
|
|
with patch.dict(os.environ, {"HERMES_TRACE_DB_PATH": ":memory:"}):
|
|
import app
|
|
|
|
if app.db.telemetry_db is not None:
|
|
app.db.telemetry_db._conn.close()
|
|
app.db.telemetry_db = None
|
|
|
|
|
|
class TestTurnPayload(unittest.TestCase):
|
|
"""Verify that full payloads are formatted and returned only once."""
|
|
|
|
def setUp(self) -> None:
|
|
"""Create isolated filesystem and repository resources for each test."""
|
|
self.test_dir = tempfile.TemporaryDirectory()
|
|
self.database = app.db.TelemetryDB(
|
|
os.path.join(self.test_dir.name, "hermes-trace.db")
|
|
)
|
|
self.database.init_db()
|
|
app.db.telemetry_db = self.database
|
|
self.repository = create_autospec(app.db.TelemetryDB, instance=True)
|
|
|
|
def tearDown(self) -> None:
|
|
"""Close SQLite before removing its temporary directory."""
|
|
self.database._conn.close()
|
|
app.db.telemetry_db = None
|
|
self.test_dir.cleanup()
|
|
|
|
def _request(self, query: bytes = b"") -> Request:
|
|
"""Build a minimal Starlette request for the payload route."""
|
|
return Request(
|
|
{
|
|
"type": "http",
|
|
"method": "GET",
|
|
"path": "/turn/1/payload",
|
|
"query_string": query,
|
|
"headers": [],
|
|
}
|
|
)
|
|
|
|
def test_returns_one_valid_formatted_json_copy(self) -> None:
|
|
"""Newlines inside string values render as actual line breaks."""
|
|
raw = json.dumps({"content": "line 1\nline 2"})
|
|
self.repository.get_turn_payload.return_value = {"full_request": raw}
|
|
request = self._request(b"type=request")
|
|
|
|
with (
|
|
patch.object(app.db, "get_db", return_value=self.repository),
|
|
patch.object(app, "_pretty_json", wraps=app._pretty_json) as pretty_json,
|
|
):
|
|
response = asyncio.run(app.turn_payload(request, 1))
|
|
|
|
self.repository.get_turn_payload.assert_called_once_with(1, "request")
|
|
pretty_json.assert_called_once_with(raw)
|
|
body = response.body.decode()
|
|
self.assertEqual(body.count("<textarea"), 1)
|
|
self.assertNotIn("json-toggle", body)
|
|
|
|
match = re.search(r"<textarea[^>]*>(.*?)</textarea>", body, re.DOTALL)
|
|
self.assertIsNotNone(match)
|
|
rendered = html.unescape(match.group(1)) if match else ""
|
|
# The \\n inside string values is replaced with actual newlines for
|
|
# visual display in the textarea, so the content is no longer valid
|
|
# JSON — verify the visual result instead.
|
|
self.assertIn('"content": "line 1', rendered)
|
|
self.assertIn("line 2", rendered)
|
|
|
|
def test_response_type_loads_full_response(self) -> None:
|
|
"""The response selector reads and formats full_response."""
|
|
raw = json.dumps({"answer": 42})
|
|
self.repository.get_turn_payload.return_value = {"full_response": raw}
|
|
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(app.turn_payload(self._request(b"type=response"), 7))
|
|
|
|
self.repository.get_turn_payload.assert_called_once_with(7, "response")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertIn('"answer": 42', html.unescape(response.body.decode()))
|
|
|
|
def test_invalid_type_returns_400_without_database_access(self) -> None:
|
|
"""Unknown payload selectors are rejected before repository access."""
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(app.turn_payload(self._request(b"type=other"), 1))
|
|
|
|
self.assertEqual(response.status_code, 400)
|
|
self.assertIn("Invalid type", response.body.decode())
|
|
self.repository.get_turn_payload.assert_not_called()
|
|
|
|
def test_missing_turn_returns_404(self) -> None:
|
|
"""A missing database turn produces an HTMX-friendly 404 fragment."""
|
|
self.repository.get_turn_payload.return_value = None
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(app.turn_payload(self._request(), 99))
|
|
|
|
self.assertEqual(response.status_code, 404)
|
|
self.assertIn("Turn not found", response.body.decode())
|
|
self.repository.get_turn_payload.assert_called_once_with(99, "request")
|
|
|
|
def test_empty_request_and_response_render_empty_state(self) -> None:
|
|
"""Missing or empty payload fields render without formatting errors."""
|
|
for query, turn in (
|
|
(b"type=request", {"full_request": ""}),
|
|
(b"type=response", {"full_response": ""}),
|
|
):
|
|
with self.subTest(query=query):
|
|
self.repository.reset_mock()
|
|
self.repository.get_turn_payload.return_value = turn
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(app.turn_payload(self._request(query), 1))
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertIn("(empty)", response.body.decode())
|
|
self.assertNotIn("<textarea", response.body.decode())
|
|
self.repository.get_turn_payload.assert_called_once_with(
|
|
1, query.decode().split("=", 1)[1]
|
|
)
|
|
|
|
|
|
class TestTurnDetail(unittest.TestCase):
|
|
"""Verify the detail and legacy waterfall routes use safe projections."""
|
|
|
|
def setUp(self) -> None:
|
|
"""Create an isolated repository mock for each route test."""
|
|
self.repository = create_autospec(app.db.TelemetryDB, instance=True)
|
|
|
|
def _request(self) -> Request:
|
|
"""Build a minimal request for an HTMX fragment route."""
|
|
return Request(
|
|
{
|
|
"type": "http",
|
|
"method": "GET",
|
|
"path": "/turn/1",
|
|
"query_string": b"",
|
|
"headers": [],
|
|
}
|
|
)
|
|
|
|
def test_detail_uses_preview_query_and_loads_user_input_separately(self) -> None:
|
|
"""Detail metadata stays projected while user input comes from its own query."""
|
|
self.repository.get_turn_preview.return_value = {
|
|
"id": 1,
|
|
"model": "model-1",
|
|
"request_preview": "preview user input",
|
|
"response_preview": "preview response",
|
|
"elapsed_ms": 100,
|
|
"input_tokens": 10,
|
|
"output_tokens": 20,
|
|
"total_tokens": 30,
|
|
"cache_read_tokens": None,
|
|
"cache_write_tokens": None,
|
|
"reasoning_tokens": None,
|
|
"finish_reason": "stop",
|
|
"turn_type": "main",
|
|
"tool_calls": [],
|
|
}
|
|
self.repository.get_turn_user_input.return_value = "actual user input"
|
|
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(app.turn_detail(self._request(), 1))
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.repository.get_turn_preview.assert_called_once_with(1)
|
|
self.repository.get_turn_user_input.assert_called_once_with(1)
|
|
self.repository.get_turn_detail.assert_not_called()
|
|
body = response.body.decode()
|
|
self.assertIn("actual user input", body)
|
|
self.assertNotIn("preview user input", body)
|
|
self.assertIn("preview response", body)
|
|
|
|
def test_waterfall_rejects_turn_from_another_session(self) -> None:
|
|
"""The legacy waterfall route enforces the session URL ownership."""
|
|
self.repository.get_turn_detail.return_value = {
|
|
"id": 7,
|
|
"session_id": "actual-session",
|
|
"tool_calls": [],
|
|
}
|
|
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(
|
|
app.waterfall_view(self._request(), "requested-session", 7)
|
|
)
|
|
|
|
self.assertEqual(response.status_code, 404)
|
|
self.assertIn("Turn not found", response.body.decode())
|
|
|
|
def test_waterfall_renders_for_matching_session(self) -> None:
|
|
"""A matching session still reaches the legacy waterfall template."""
|
|
self.repository.get_turn_detail.return_value = {
|
|
"id": 7,
|
|
"session_id": "requested-session",
|
|
"elapsed_ms": 100,
|
|
"api_call_count": 1,
|
|
"input_tokens": 10,
|
|
"output_tokens": 20,
|
|
"total_tokens": 30,
|
|
"finish_reason": "stop",
|
|
"response_preview": "preview response",
|
|
"tool_calls": [],
|
|
}
|
|
|
|
with patch.object(app.db, "get_db", return_value=self.repository):
|
|
response = asyncio.run(
|
|
app.waterfall_view(self._request(), "requested-session", 7)
|
|
)
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertIn("No tool calls in this turn", response.body.decode())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|