hermes-trace/tests/test_app_payload.py
XLion 6d49b0bf14
fix: render newlines in JSON payload textarea
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).
2026-07-23 17:39:17 +08:00

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()