Experimental/brain-of-reese
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ece93a7c8f0e7b159fe0211b6c91c9ccee693df6
brain-of-reese/tests/e2e/test_chat_history.py
T

435 lines
18 KiB
Python
Raw Blame History

"""Phase 50 E2E (Playwright): save & view chat history.
TODO.md L5 (owner 2026-08-29): "Need a way to save and view chat
history in a new page, then return to that history with a click"
Run in isolation (DB must be up: ``podman compose up -d db``):
uv run pytest tests/e2e/test_chat_history.py -v --no-cov
The owner-locked loop under test (A10 extension, 2026-08-29):
* **Save** — on the chat page, admin-only (the pill ships hidden and
whoami reveals it): the current conversation POSTs to ``/api/chats``
(auto-title = the first question, whitespace-collapsed, 120-char cap)
and links to the created row; a re-Save PUTs the SAME row (upsert);
"New chat" unlinks, so the next Save creates again;
* **History** — ``/history.html`` lists the saved chats in a full-width
table (Title | Messages | Updated | Actions); the Title cell IS the
Open link (``/?chat=<id>`` — "return to that history with a click"),
and Delete is the inline two-step confirm (owner-locked: no native
confirm dialog — a real ``window.confirm`` would hang Playwright, so
the inline pair appearing is itself pinned);
* **Open** — ``/?chat=<id>`` (valid uuid + admin) boots into the saved
conversation through the SAME restore path as the phase-14 local
session (pixel-identical), links it, and a subsequent Save updates
that row; a deleted/unknown id degrades to the local restore with the
error banner;
* **Anonymous** — no Save button, no History nav link, the History page
shows the gated state WITHOUT ever fetching ``/api/chats`` (the router
403s them — pinned via the request log), and the API 403s.
DB isolation: the shared e2e Postgres keeps ``saved_chats`` rows across
suites, so every test here uses a DISTINCTIVE question text (its
auto-title is therefore unique), never asserts on absolute row counts,
and deletes the rows it creates in a ``finally`` (admin cookie). The KB
tables are truncated + re-seeded the house way (deterministic mock
embeddings); ``saved_chats`` is never touched by the reset.
"""
from __future__ import annotations
import asyncio
from pathlib import Path
from threading import Thread
from typing import Any
import httpx
from playwright.sync_api import Page, expect
from sqlalchemy import text
from app.config import Settings
from app.db import SessionLocal
from app.rag.importer import ImportSummary, import_sources
from app.rag.llm import LLMClient
from e2e.auth_helpers import login
REPO = Path(__file__).resolve().parents[2]
FIXTURES = REPO / "tests" / "fixtures" / "docs"
MOCK_ANSWER_MARKER = "Deterministic mock answer for E2E"
#: Phase 10 viewer URL + phase 13 back=/ (the restored chip must be
#: byte-identical to the live-rendered one).
CHIP_HREF = "/document.html?source=docs&path=homelab%2Fkubernetes.md&back=%2F"
async def _import_fixtures(mock_port: int) -> ImportSummary:
kwargs: dict[str, Any] = {"_env_file": None, "llm_base_url": f"http://127.0.0.1:{mock_port}/v1"}
settings = Settings(**kwargs) # pyright: ignore[reportCallIssue]
return await import_sources([FIXTURES], LLMClient(settings))
def _run_in_thread(coro: Any) -> Any:
"""Run a coroutine on a worker thread.
Playwright's sync API keeps an asyncio loop running on the test thread,
so ``asyncio.run`` cannot be called directly from a test body.
"""
box: dict[str, Any] = {}
def runner() -> None:
try:
box["value"] = asyncio.run(coro)
except BaseException as e: # noqa: BLE001 — re-raised on the test thread
box["error"] = e
t = Thread(target=runner)
t.start()
t.join()
if "error" in box:
raise box["error"]
return box["value"]
def _reset_db(mock_port: int, seed: bool) -> ImportSummary | None:
"""Truncate the KB (and query log + steering notes — deterministic
mock answers), then optionally re-import fixtures. ``saved_chats``
is deliberately NOT touched: rows persist across suites and every
test here cleans up after itself."""
with SessionLocal() as db:
db.execute(
text("TRUNCATE chunks, documents, query_log, steering_notes")
)
db.commit()
if not seed:
return None
return _run_in_thread(_import_fixtures(mock_port))
def _ask(page: Page, question: str) -> None:
"""Send one turn and wait until the grounded answer has fully
landed (the ``done`` event restored the Send button)."""
page.fill("#message-input", question)
page.click("#send-btn")
expect(page.locator(".msg.user .bubble").last).to_contain_text(question)
expect(page.locator(".msg.brain .bubble").last).to_contain_text(
MOCK_ANSWER_MARKER, timeout=30_000
)
expect(page.locator("#send-btn")).to_be_enabled()
expect(page.locator("#send-label")).to_have_text("Send")
def _admin_cookies(page: Page) -> dict[str, str]:
"""The signed session cookies the browser holds after a form login —
used to call the admin API with plain httpx (the test's API side
sees exactly what the signed-in browser sees)."""
return {
c["name"]: c["value"]
for c in page.context.cookies()
if "name" in c and "value" in c
}
def _chats(app_url: str, cookies: dict[str, str]) -> list[dict[str, Any]]:
r = httpx.get(f"{app_url}/api/chats", timeout=10, cookies=cookies)
assert r.status_code == 200
return r.json()["chats"]
def _find_row(
rows: list[dict[str, Any]], title: str
) -> dict[str, Any] | None:
return next((c for c in rows if c["title"] == title), None)
def _delete_chat(app_url: str, cookies: dict[str, str], chat_id: str) -> None:
"""Best-effort row cleanup (a 404 — already deleted — is fine)."""
httpx.delete(f"{app_url}/api/chats/{chat_id}", timeout=10, cookies=cookies)
def _save(page: Page) -> None:
"""Press Save and wait for the live-region confirmation (the
never-stale contract: the status line is the success feedback)."""
page.locator("#save-chat-btn").click()
expect(page.locator("#send-status")).to_have_text("Conversation saved.")
# ---------------------------------------------------------------------------
# 1. Save on the chat page → the row exists (UI + API agree)
# ---------------------------------------------------------------------------
def test_save_and_see_history(
page: Page, app_url: str, mock_llm: int, db_ready: None
) -> None:
_reset_db(mock_llm, seed=True)
page.set_default_timeout(30_000)
login(page, app_url, next="/")
expect(page).to_have_url(app_url + "/", timeout=30_000)
q = "How is my Kubernetes cluster set up? (hist-save)"
_ask(page, q)
# Admin: the Save pill is revealed (ship-hidden, whoami reveals it).
save = page.locator("#save-chat-btn")
expect(save).to_be_visible()
expect(save).to_have_attribute("aria-label", "Save chat")
save.click()
expect(page.locator("#send-status")).to_have_text("Conversation saved.")
cookies = _admin_cookies(page)
created: str | None = None
try:
# The API agrees: the row exists, auto-titled from the first
# question (whitespace-collapsed, <=120 chars), two messages.
row = _find_row(_chats(app_url, cookies), " ".join(q.split())[:120])
assert row is not None, "the saved chat row must exist"
assert row["message_count"] == 2
created = row["id"]
# The History page shows it: the row for THIS chat carries the
# auto-title and the message count.
page.goto(app_url + "/history.html")
link = page.locator(f"#history-tbody a[href='/?chat={created}']")
expect(link).to_be_visible(timeout=15_000)
expect(link).to_have_text(" ".join(q.split())[:120])
row_tr = page.locator(
"#history-tbody tr", has=page.locator(f"a[href='/?chat={created}']")
)
expect(row_tr.locator(".history-count-cell")).to_have_text("2")
finally:
if created is not None:
_delete_chat(app_url, cookies, created)
# ---------------------------------------------------------------------------
# 2. History → click the title → back in the saved conversation; the
# conversation continues and a re-Save updates the SAME row
# ---------------------------------------------------------------------------
def test_open_chat_returns_to_history(
page: Page, app_url: str, mock_llm: int, db_ready: None
) -> None:
_reset_db(mock_llm, seed=True)
page.set_default_timeout(30_000)
login(page, app_url, next="/")
expect(page).to_have_url(app_url + "/", timeout=30_000)
q = "How is my Kubernetes cluster set up? (hist-open)"
_ask(page, q)
# The answer text the History session saw (rendered bubble).
answer_before = page.locator(".msg.brain .bubble").first.inner_text()
_save(page)
cookies = _admin_cookies(page)
row = _find_row(_chats(app_url, cookies), q)
assert row is not None
chat_id = row["id"]
try:
# From the History page, the title IS the Open link…
page.goto(app_url + "/history.html")
link = page.locator(f"#history-tbody a[href='/?chat={chat_id}']")
expect(link).to_be_visible(timeout=15_000)
doc_requests: list[str] = []
page.on(
"request",
lambda r: doc_requests.append(r.url)
if r.resource_type == "document"
else None,
)
link.click()
# …and the click navigates to /?chat=<uuid> ("return to that
# history with a click"). app.js then normalizes the one-shot
# ?chat= param back to /, so the navigation target itself is
# what gets pinned here.
assert any(u == app_url + "/?chat=" + chat_id for u in doc_requests), (
f"the title link must navigate to /?chat={chat_id}: {doc_requests}"
)
# The chat rendered the saved conversation…
expect(page.locator(".msg.user .bubble")).to_have_count(1)
expect(page.locator(".msg.user .bubble")).to_contain_text(q)
bubble = page.locator(".msg.brain .bubble").first
expect(bubble).to_contain_text(q)
expect(bubble).to_contain_text(MOCK_ANSWER_MARKER)
# …the SAME answer text the History session saw (pixel-identical
# restore through renderStoredMessage)…
assert bubble.inner_text() == answer_before
# …with its source chip restored byte-identically.
chip = page.locator(".msg.brain .source-chip", has_text="kubernetes.md")
expect(chip).to_have_count(1)
expect(chip.first).to_have_attribute("href", CHIP_HREF)
# The conversation continues: a new turn streams fine…
_ask(page, "How is my Kubernetes cluster set up? (hist-open-2)")
expect(page.locator(".msg.user .bubble")).to_have_count(2)
# …and a re-Save UPSERTS: the same single row, count grown to 4.
_save(page)
mine = [c for c in _chats(app_url, cookies) if c["title"] == q]
assert len(mine) == 1, "the re-Save must not spawn a second row"
assert mine[0]["id"] == chat_id, "the re-Save updates the SAME row"
assert mine[0]["message_count"] == 4
finally:
_delete_chat(app_url, cookies, chat_id)
# ---------------------------------------------------------------------------
# 3. "New chat" unlinks: the next Save is a fresh create, not an update
# of the previously saved conversation
# ---------------------------------------------------------------------------
def test_new_chat_unlinks(
page: Page, app_url: str, mock_llm: int, db_ready: None
) -> None:
_reset_db(mock_llm, seed=True)
page.set_default_timeout(30_000)
login(page, app_url, next="/")
expect(page).to_have_url(app_url + "/", timeout=30_000)
q1 = "How is my Kubernetes cluster set up? (hist-unlink)"
_ask(page, q1)
_save(page)
cookies = _admin_cookies(page)
cleanup: list[str] = []
try:
row1 = _find_row(_chats(app_url, cookies), q1)
assert row1 is not None
cleanup.append(row1["id"])
# New chat clears the conversation AND unlinks it from the row.
page.locator("#new-chat-btn").click()
expect(page.locator("#send-status")).to_contain_text("New chat started")
expect(page.locator(".msg")).to_have_count(0)
# A fresh conversation, saved: a NEW row (a create, not the
# previous row's update) — the list now carries two of ours.
q2 = "How is my Kubernetes cluster set up? (hist-unlink-2)"
_ask(page, q2)
_save(page)
rows = _chats(app_url, cookies)
mine = [c for c in rows if c["title"] in (q1, q2)]
assert len(mine) == 2, "Save after New chat must create a second row"
a = _find_row(rows, q1)
b = _find_row(rows, q2)
assert a is not None and b is not None
assert a["id"] != b["id"], "the fresh Save must not reuse the old row"
assert a["message_count"] == 2, "the unlinked conversation was untouched"
cleanup.append(b["id"])
finally:
for chat_id in cleanup:
_delete_chat(app_url, cookies, chat_id)
# ---------------------------------------------------------------------------
# 4. Delete: the inline two-step confirm (no native dialog), the row is
# gone (the API 404s), and /?chat=<id> degrades to the local restore
# ---------------------------------------------------------------------------
def test_delete_two_step(
page: Page, app_url: str, mock_llm: int, db_ready: None
) -> None:
_reset_db(mock_llm, seed=True)
page.set_default_timeout(30_000)
login(page, app_url, next="/")
expect(page).to_have_url(app_url + "/", timeout=30_000)
q = "How is my Kubernetes cluster set up? (hist-delete)"
_ask(page, q)
_save(page)
cookies = _admin_cookies(page)
row = _find_row(_chats(app_url, cookies), q)
assert row is not None
chat_id = row["id"]
try:
page.goto(app_url + "/history.html")
tr = page.locator(
"#history-tbody tr", has=page.locator(f"a[href='/?chat={chat_id}']")
)
expect(tr.locator("a.history-title-link")).to_be_visible(timeout=15_000)
# Step 1: the Delete button swaps, IN PLACE, for the "Delete?
# [Yes] [No]" pair — a real window.confirm would hang Playwright
# here, so the pair appearing is the pinned contract.
tr.locator("button.history-delete").click()
expect(tr.locator(".history-confirm-yes")).to_be_visible()
expect(tr.locator(".history-confirm-no")).to_be_visible()
# "No" cancels: the pair is gone, the Delete button returns, the
# row stays.
tr.locator(".history-confirm-no").click()
expect(tr.locator(".history-confirm-yes")).to_have_count(0)
expect(tr.locator("button.history-delete")).to_be_visible()
expect(page.locator(f"#history-tbody a[href='/?chat={chat_id}']")).to_have_count(1)
# Step 2: Delete → "Yes" removes the row + the live-region line.
tr.locator("button.history-delete").click()
tr.locator(".history-confirm-yes").click()
expect(page.locator(f"#history-tbody a[href='/?chat={chat_id}']")).to_have_count(0)
expect(page.locator("#history-status")).to_contain_text(f'Deleted "{q}".')
# The API agrees: the id is unknown now.
r = httpx.get(f"{app_url}/api/chats/{chat_id}", timeout=10, cookies=cookies)
assert r.status_code == 404
# Degradation: /?chat=<deleted id> shows the error banner and
# falls through to the local restore (this context's
# localStorage still holds the conversation from the ask above).
page.goto(app_url + f"/?chat={chat_id}")
banner = page.locator("#kb-banner")
expect(banner).to_be_visible(timeout=15_000)
expect(banner).to_contain_text("That saved chat isn't available")
expect(page.locator(".msg.user .bubble")).to_contain_text(q)
expect(page.locator(".msg.brain .bubble").first).to_contain_text(
MOCK_ANSWER_MARKER, timeout=15_000
)
finally:
# No-op when the delete above succeeded (the 404 is handled).
_delete_chat(app_url, cookies, chat_id)
# ---------------------------------------------------------------------------
# 5. Anonymous: no Save button, no History nav link, the History page is
# gated WITHOUT fetching /api/chats, and the API 403s
# ---------------------------------------------------------------------------
def test_anonymous_cannot(
page: Page, app_url: str, mock_llm: int, db_ready: None
) -> None:
_reset_db(mock_llm, seed=True)
page.set_default_timeout(30_000)
# A fresh context is anonymous by construction (no login).
requests: list[str] = []
page.on("request", lambda r: requests.append(r.url))
page.goto(app_url + "/")
# Settled anonymous state (the whoami round-trip has landed)…
expect(page.locator("#sign-in-link")).to_be_visible(timeout=15_000)
# …and the phase-50 surface is absent for anonymous: no Save pill,
# no History nav link (both ship hidden and stay hidden).
expect(page.locator("#save-chat-btn")).to_be_hidden()
expect(page.locator("#nav-history")).to_be_hidden()
# Direct visit to the History page: it loads and shows the gated
# state (the table wrapped away) — and NEVER calls /api/chats (the
# router 403s anonymous, so the page must not even try).
page.goto(app_url + "/history.html")
expect(page.locator("#history-gate")).to_be_visible(timeout=15_000)
expect(page.locator("#history-table-wrap")).to_be_hidden()
assert not any("/api/chats" in u for u in requests), (
f"the anonymous History page must not fetch /api/chats: {requests}"
)
# And the API gate itself: 403 without the admin cookie.
r = httpx.get(f"{app_url}/api/chats", timeout=10)
assert r.status_code == 403
Reference in New Issue View Git Blame Copy Permalink