404 lines
17 KiB
Python
404 lines
17 KiB
Python
"""Console-noise regressions: git-info 404 on state.db-only sessions, pollers
|
|
that keep 409ing after a profile-cookie flip, and the unused pwa-startup preload."""
|
|
import io
|
|
import json
|
|
import shutil
|
|
import subprocess
|
|
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
|
|
import pytest
|
|
|
|
import api.routes as routes
|
|
|
|
REPO = Path(__file__).resolve().parent.parent
|
|
MESSAGES_JS = (REPO / "static" / "messages.js").read_text(encoding="utf-8")
|
|
SESSIONS_JS = (REPO / "static" / "sessions.js").read_text(encoding="utf-8")
|
|
INDEX_HTML = (REPO / "static" / "index.html").read_text(encoding="utf-8")
|
|
|
|
|
|
class _Handler:
|
|
def __init__(self):
|
|
self.wfile = io.BytesIO()
|
|
self.headers = {}
|
|
self.status = None
|
|
|
|
def send_response(self, status):
|
|
self.status = status
|
|
|
|
def send_header(self, *_a):
|
|
pass
|
|
|
|
def end_headers(self):
|
|
pass
|
|
|
|
def payload(self):
|
|
return json.loads(self.wfile.getvalue().decode("utf-8"))
|
|
|
|
|
|
def _git_info(sid):
|
|
h = _Handler()
|
|
routes.handle_get(h, urlparse(f"/api/git-info?session_id={sid}"))
|
|
return h.status, h.payload()
|
|
|
|
|
|
@pytest.fixture
|
|
def git_repo(tmp_path):
|
|
if not shutil.which("git"):
|
|
pytest.skip("git not installed")
|
|
run = lambda *a: subprocess.run(["git", "-C", str(tmp_path), *a], check=True, capture_output=True)
|
|
run("init", "-q", "-b", "main")
|
|
(tmp_path / "a.txt").write_text("a")
|
|
run("add", "a.txt")
|
|
run("-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", "init")
|
|
(tmp_path / "b.txt").write_text("b")
|
|
return tmp_path
|
|
|
|
|
|
def _state_db_only(monkeypatch, sid, row):
|
|
def _missing(*_a, **_kw):
|
|
raise KeyError(sid)
|
|
|
|
monkeypatch.setattr(routes, "get_session", _missing)
|
|
monkeypatch.setattr(routes, "get_cli_sessions", lambda *_a, **_kw: [row] if row else [])
|
|
|
|
|
|
def test_git_info_serves_state_db_only_session(monkeypatch, git_repo):
|
|
sid = "20260923_175914_e47592"
|
|
_state_db_only(monkeypatch, sid, {"session_id": sid, "workspace": str(git_repo)})
|
|
monkeypatch.setattr(routes, "resolve_trusted_workspace", lambda p, *_a, **_kw: Path(p))
|
|
|
|
status, body = _git_info(sid)
|
|
|
|
assert status == 200, body
|
|
assert body["git"]["is_git"] is True
|
|
assert body["git"]["branch"] == "main"
|
|
assert body["git"]["untracked"] == 1
|
|
|
|
|
|
def test_git_info_untrusted_state_db_workspace_is_not_inspected(monkeypatch, git_repo):
|
|
sid = "20260923_175914_e9d4bd"
|
|
_state_db_only(monkeypatch, sid, {"session_id": sid, "workspace": str(git_repo)})
|
|
|
|
def _untrusted(*_a, **_kw):
|
|
raise ValueError("outside trusted roots")
|
|
|
|
monkeypatch.setattr(routes, "resolve_trusted_workspace", _untrusted)
|
|
assert _git_info(sid) == (200, {"git": None})
|
|
|
|
|
|
def test_git_info_state_db_session_without_workspace_has_no_badge(monkeypatch):
|
|
sid = "20260923_000000_abcdef"
|
|
_state_db_only(monkeypatch, sid, {"session_id": sid, "workspace": ""})
|
|
monkeypatch.setattr(
|
|
routes, "resolve_trusted_workspace",
|
|
lambda *_a, **_kw: pytest.fail("must not fall back to the default workspace"),
|
|
)
|
|
assert _git_info(sid) == (200, {"git": None})
|
|
|
|
|
|
def test_git_info_unknown_session_still_404s(monkeypatch):
|
|
_state_db_only(monkeypatch, "nope", None)
|
|
status, body = _git_info("nope")
|
|
assert status == 404 and body["error"] == "Session not found"
|
|
|
|
|
|
# ── frontend pollers, driven through node with the real functions ─────────────
|
|
|
|
def _extract_fn(src, name):
|
|
start = src.index(f"function {name}(")
|
|
brace = src.index("{", src.index(")", start))
|
|
depth, i = 1, brace + 1
|
|
while depth:
|
|
depth += {"{": 1, "}": -1}.get(src[i], 0)
|
|
i += 1
|
|
return src[start:i]
|
|
|
|
|
|
_HARNESS = r"""
|
|
var S = {session: {session_id: 'sid1'}, busy: false};
|
|
var calls = {api: 0, warn: 0, hide: 0};
|
|
var _approvalPollTimer = null, _approvalEventSource = null, _approvalSSEHealthTimer = null;
|
|
var _approvalFallbackPollInFlight = false, _approvalPollingSessionId = 'sid1';
|
|
var _clarifyEventSource = null, _clarifyFallbackTimer = null, _clarifyHealthTimer = null;
|
|
var _clarifyFallbackPollInFlight = false, _clarifyPollingSessionId = null, _clarifyMissingEndpointWarned = false;
|
|
var _approvalPendingBySession = new Map();
|
|
var _approvalProfilePausedSessionId = null, _clarifyProfilePausedSessionId = null;
|
|
var _promptPollerFocusEpoch = 0;
|
|
function _approvalPromptGeneration(){ return 0; }
|
|
function _clarifyPromptGeneration(){ return 0; }
|
|
function _approvalPollingSessionMissingOrMismatched(sid){ return !sid || !S.session || S.session.session_id !== sid; }
|
|
function _hideApprovalCardIfOwner(){ calls.hide++; }
|
|
function _hideClarifyCardIfOwner(){ calls.hide++; }
|
|
function _clearApprovalPendingForSession(){}
|
|
function _clearClarifyPendingForSession(){}
|
|
function showApprovalForSession(){}
|
|
function showClarifyForSession(){}
|
|
function setComposerStatus(){}
|
|
function showToast(){}
|
|
console.warn = function(){ calls.warn++; };
|
|
var timers = [];
|
|
setInterval = function(fn){ timers.push(fn); return timers.length; };
|
|
clearInterval = function(){};
|
|
async function api(){
|
|
calls.api++;
|
|
var e = new Error('Session belongs to a different profile');
|
|
e.status = STATUS;
|
|
e.body = JSON.stringify(BODY);
|
|
throw e;
|
|
}
|
|
"""
|
|
|
|
|
|
def _run_poller(start_fn, status, body):
|
|
node = shutil.which("node")
|
|
if not node:
|
|
pytest.skip("node not installed")
|
|
fns = [
|
|
_extract_fn(SESSIONS_JS, "_sessionProfileMismatchFromError"),
|
|
_extract_fn(MESSAGES_JS, "_startApprovalFallbackPoll"),
|
|
_extract_fn(MESSAGES_JS, "stopApprovalPollingForSession"),
|
|
_extract_fn(MESSAGES_JS, "stopApprovalPolling"),
|
|
_extract_fn(MESSAGES_JS, "_startClarifyFallbackPoll"),
|
|
_extract_fn(MESSAGES_JS, "stopClarifyPollingForSession"),
|
|
_extract_fn(MESSAGES_JS, "stopClarifyPolling"),
|
|
]
|
|
script = (
|
|
_HARNESS.replace("STATUS", str(status)).replace("BODY", json.dumps(body))
|
|
+ "\n".join(fns)
|
|
+ f"""
|
|
(async () => {{
|
|
{start_fn}('sid1');
|
|
await new Promise(r => setTimeout(r, 0));
|
|
const pollingAfterFirst = {'_approvalPollingSessionId' if 'Approval' in start_fn else '_clarifyPollingSessionId'};
|
|
process.stdout.write(JSON.stringify({{calls, pollingAfterFirst}}));
|
|
}})();
|
|
"""
|
|
)
|
|
out = subprocess.run([node, "-e", script], capture_output=True, text=True, timeout=30)
|
|
assert out.returncode == 0, out.stderr
|
|
return json.loads(out.stdout)
|
|
|
|
|
|
_MISMATCH = {"error": "Session belongs to a different profile", "code": "session_profile_mismatch",
|
|
"session_id": "sid1", "profile": "deepseek"}
|
|
|
|
|
|
def test_approval_poll_stops_on_profile_mismatch_409():
|
|
r = _run_poller("_startApprovalFallbackPoll", 409, _MISMATCH)
|
|
assert r["calls"]["api"] == 1
|
|
assert r["pollingAfterFirst"] is None, "approval poller must stop after a session_profile_mismatch 409"
|
|
assert r["calls"]["hide"] == 0, "a live approval card must stay standing"
|
|
|
|
|
|
def test_approval_poll_keeps_running_on_other_errors():
|
|
r = _run_poller("_startApprovalFallbackPoll", 500, {"error": "boom"})
|
|
assert r["pollingAfterFirst"] == "sid1"
|
|
|
|
|
|
def test_clarify_poll_stops_quietly_on_profile_mismatch_409():
|
|
r = _run_poller("_startClarifyFallbackPoll", 409, _MISMATCH)
|
|
assert r["calls"]["api"] == 1
|
|
assert r["pollingAfterFirst"] is None, "clarify poller must stop after a session_profile_mismatch 409"
|
|
assert r["calls"]["warn"] == 0, "expected profile mismatch must not log '[clarify] pending poll failed'"
|
|
assert r["calls"]["hide"] == 0, "a live clarify card must stay standing"
|
|
|
|
|
|
def test_clarify_poll_still_warns_on_unexpected_errors():
|
|
r = _run_poller("_startClarifyFallbackPoll", 500, {"error": "boom"})
|
|
assert r["calls"]["warn"] == 1
|
|
assert r["pollingAfterFirst"] == "sid1"
|
|
|
|
|
|
def test_pwa_startup_is_not_preloaded_next_to_its_own_blocking_script():
|
|
assert '<script src="static/pwa-startup.js?v=__WEBUI_VERSION__"></script>' in INDEX_HTML
|
|
assert 'rel="preload" href="static/pwa-startup.js' not in INDEX_HTML
|
|
|
|
|
|
def _run_stale_replacement(start_fn, stop_fn, polling_var):
|
|
"""Poller A's request is in flight; a same-session refresh replaces it with
|
|
poller B; then A's request fails with a profile-mismatch 409."""
|
|
node = shutil.which("node")
|
|
if not node:
|
|
pytest.skip("node not installed")
|
|
fns = [
|
|
_extract_fn(SESSIONS_JS, "_sessionProfileMismatchFromError"),
|
|
_extract_fn(MESSAGES_JS, start_fn),
|
|
_extract_fn(MESSAGES_JS, stop_fn),
|
|
]
|
|
harness = _HARNESS.replace("STATUS", "409").replace("BODY", json.dumps(_MISMATCH))
|
|
harness = harness.replace("async function api(){", "var pending = [];\nasync function api(){\n if (pending) return new Promise((_, rej) => pending.push(rej));")
|
|
script = harness + "\n".join(fns) + f"""
|
|
(async () => {{
|
|
{start_fn}('sid1'); // poller A: first request hangs
|
|
{stop_fn}(); // same-session refresh
|
|
{polling_var} = 'sid1'; // startApprovalPolling() sets this before the fallback poll
|
|
{start_fn}('sid1'); // poller B: its request hangs too
|
|
const timerB = {"_approvalPollTimer" if "Approval" in start_fn else "_clarifyFallbackTimer"};
|
|
const e = new Error('Session belongs to a different profile');
|
|
e.status = 409; e.body = JSON.stringify({json.dumps(_MISMATCH)});
|
|
pending[0](e); // late 409 for poller A
|
|
await new Promise(r => setTimeout(r, 0));
|
|
process.stdout.write(JSON.stringify({{
|
|
polling: {polling_var},
|
|
timerAlive: {"_approvalPollTimer" if "Approval" in start_fn else "_clarifyFallbackTimer"} === timerB,
|
|
inFlight: {"_approvalFallbackPollInFlight" if "Approval" in start_fn else "_clarifyFallbackPollInFlight"},
|
|
}}));
|
|
}})();
|
|
"""
|
|
out = subprocess.run([node, "-e", script], capture_output=True, text=True, timeout=30)
|
|
assert out.returncode == 0, out.stderr
|
|
return json.loads(out.stdout)
|
|
|
|
|
|
@pytest.mark.parametrize("start_fn,stop_fn,polling_var", [
|
|
("_startApprovalFallbackPoll", "stopApprovalPolling", "_approvalPollingSessionId"),
|
|
("_startClarifyFallbackPoll", "stopClarifyPolling", "_clarifyPollingSessionId"),
|
|
])
|
|
def test_stale_profile_mismatch_does_not_stop_replacement_poller(start_fn, stop_fn, polling_var):
|
|
r = _run_stale_replacement(start_fn, stop_fn, polling_var)
|
|
assert r["polling"] == "sid1", "a late 409 from a replaced poller must not stop its successor"
|
|
assert r["timerAlive"] is True
|
|
assert r["inFlight"] is True, "the successor's in-flight guard must not be cleared by the stale request"
|
|
|
|
|
|
def _run_profile_round_trip(kind):
|
|
"""Mismatch 409 pauses the poller; the cookie comes back, focus returns, and
|
|
the pending prompt for the still-open session must be fetched and shown."""
|
|
node = shutil.which("node")
|
|
if not node:
|
|
pytest.skip("node not installed")
|
|
approval = kind == "approval"
|
|
fns = [
|
|
_extract_fn(SESSIONS_JS, "_sessionProfileMismatchFromError"),
|
|
_extract_fn(MESSAGES_JS, "startApprovalPolling"),
|
|
_extract_fn(MESSAGES_JS, "_startApprovalFallbackPoll"),
|
|
_extract_fn(MESSAGES_JS, "stopApprovalPollingForSession"),
|
|
_extract_fn(MESSAGES_JS, "stopApprovalPolling"),
|
|
_extract_fn(MESSAGES_JS, "startClarifyPolling"),
|
|
_extract_fn(MESSAGES_JS, "_startClarifyFallbackPoll"),
|
|
_extract_fn(MESSAGES_JS, "stopClarifyPollingForSession"),
|
|
_extract_fn(MESSAGES_JS, "stopClarifyPolling"),
|
|
_extract_fn(MESSAGES_JS, "_resumeProfilePausedPromptPollers"),
|
|
]
|
|
harness = _HARNESS.replace("STATUS", "409").replace("BODY", json.dumps(_MISMATCH))
|
|
harness = harness.replace("async function api(){", "var mismatch = true;\nasync function api(){\n if (!mismatch) { calls.api++; return {pending: {id: 'p1'}}; }")
|
|
harness = harness.replace("function showApprovalForSession(){}", "function showApprovalForSession(){ calls.shown = (calls.shown||0) + 1; }")
|
|
harness = harness.replace("function showClarifyForSession(){}", "function showClarifyForSession(){ calls.shown = (calls.shown||0) + 1; }")
|
|
start = "startApprovalPolling" if approval else "startClarifyPolling"
|
|
timer = "_approvalPollTimer" if approval else "_clarifyFallbackTimer"
|
|
script = harness + "\n".join(fns) + f"""
|
|
const tick = () => new Promise(r => setTimeout(r, 0));
|
|
(async () => {{
|
|
{start}('sid1');
|
|
await tick();
|
|
const stoppedOnMismatch = {timer} === null;
|
|
_resumeProfilePausedPromptPollers(); // focus while still mismatched
|
|
await tick();
|
|
const stoppedAgain = {timer} === null;
|
|
const apiWhileMismatched = calls.api;
|
|
mismatch = false; // other tab switched the cookie back
|
|
_resumeProfilePausedPromptPollers(); // focus/visibility returns
|
|
await tick();
|
|
process.stdout.write(JSON.stringify({{stoppedOnMismatch, stoppedAgain, apiWhileMismatched,
|
|
api: calls.api, shown: calls.shown || 0, running: {timer} !== null}}));
|
|
}})();
|
|
"""
|
|
out = subprocess.run([node, "-e", script], capture_output=True, text=True, timeout=30)
|
|
assert out.returncode == 0, out.stderr
|
|
return json.loads(out.stdout)
|
|
|
|
|
|
@pytest.mark.parametrize("kind", ["approval", "clarify"])
|
|
def test_profile_round_trip_rearms_paused_poller_and_shows_pending(kind):
|
|
r = _run_profile_round_trip(kind)
|
|
assert r["stoppedOnMismatch"] is True
|
|
assert r["stoppedAgain"] is True, "a still-mismatched profile must stop the re-armed poller again"
|
|
assert r["apiWhileMismatched"] == 2
|
|
assert r["api"] == 3, "the poller must fetch again once the profile is back"
|
|
assert r["shown"] == 1, "the pending card must be shown after the profile round-trip"
|
|
assert r["running"] is True
|
|
|
|
|
|
def test_resume_does_not_rearm_for_a_different_open_session():
|
|
node = shutil.which("node")
|
|
if not node:
|
|
pytest.skip("node not installed")
|
|
script = _HARNESS.replace("STATUS", "409").replace("BODY", "{}") + _extract_fn(
|
|
MESSAGES_JS, "_resumeProfilePausedPromptPollers") + """
|
|
var started = 0;
|
|
function startApprovalPolling(){ started++; }
|
|
function startClarifyPolling(){ started++; }
|
|
_approvalProfilePausedSessionId = 'old'; _clarifyProfilePausedSessionId = 'old';
|
|
_resumeProfilePausedPromptPollers();
|
|
process.stdout.write(String(started));
|
|
"""
|
|
out = subprocess.run([node, "-e", script], capture_output=True, text=True, timeout=30)
|
|
assert out.returncode == 0, out.stderr
|
|
assert out.stdout == "0"
|
|
|
|
|
|
def _run_late_409_after_focus(kind, cookie_back):
|
|
"""The request starts under the old profile, focus returns while it is in flight,
|
|
then the old-profile 409 lands. The poller must retry once under the current
|
|
cookie instead of pausing for good; it pauses only if the retry also mismatches."""
|
|
node = shutil.which("node")
|
|
if not node:
|
|
pytest.skip("node not installed")
|
|
approval = kind == "approval"
|
|
fns = [
|
|
_extract_fn(SESSIONS_JS, "_sessionProfileMismatchFromError"),
|
|
_extract_fn(MESSAGES_JS, "startApprovalPolling"),
|
|
_extract_fn(MESSAGES_JS, "_startApprovalFallbackPoll"),
|
|
_extract_fn(MESSAGES_JS, "stopApprovalPollingForSession"),
|
|
_extract_fn(MESSAGES_JS, "stopApprovalPolling"),
|
|
_extract_fn(MESSAGES_JS, "startClarifyPolling"),
|
|
_extract_fn(MESSAGES_JS, "_startClarifyFallbackPoll"),
|
|
_extract_fn(MESSAGES_JS, "stopClarifyPollingForSession"),
|
|
_extract_fn(MESSAGES_JS, "stopClarifyPolling"),
|
|
_extract_fn(MESSAGES_JS, "_resumeProfilePausedPromptPollers"),
|
|
]
|
|
harness = _HARNESS.replace("STATUS", "409").replace("BODY", json.dumps(_MISMATCH))
|
|
harness = harness.replace("async function api(){", """var mismatch = true, releaseFirst = null;
|
|
async function api(){
|
|
if (!releaseFirst) { await new Promise(r => { releaseFirst = r; }); return _mismatchThrow(); }
|
|
if (!mismatch) { calls.api++; return {pending: {id: 'p1'}}; }
|
|
return _mismatchThrow();
|
|
}
|
|
function _mismatchThrow(){""")
|
|
harness = harness.replace("function showApprovalForSession(){}", "function showApprovalForSession(){ calls.shown = (calls.shown||0) + 1; }")
|
|
harness = harness.replace("function showClarifyForSession(){}", "function showClarifyForSession(){ calls.shown = (calls.shown||0) + 1; }")
|
|
start = "startApprovalPolling" if approval else "startClarifyPolling"
|
|
timer = "_approvalPollTimer" if approval else "_clarifyFallbackTimer"
|
|
script = harness + "\n".join(fns) + f"""
|
|
const tick = () => new Promise(r => setTimeout(r, 0));
|
|
(async () => {{
|
|
{start}('sid1');
|
|
await tick(); // first request is in flight under the old cookie
|
|
mismatch = {'false' if cookie_back else 'true'}; // other tab switches the cookie (back or not)
|
|
_resumeProfilePausedPromptPollers(); // focus returns: nothing paused yet, so nothing to restart
|
|
releaseFirst(); // the late old-profile 409 lands
|
|
for (let i = 0; i < 5; i++) await tick();
|
|
process.stdout.write(JSON.stringify({{api: calls.api, shown: calls.shown || 0,
|
|
running: {timer} !== null}}));
|
|
}})();
|
|
"""
|
|
out = subprocess.run([node, "-e", script], capture_output=True, text=True, timeout=30)
|
|
assert out.returncode == 0, out.stderr
|
|
return json.loads(out.stdout)
|
|
|
|
|
|
@pytest.mark.parametrize("kind", ["approval", "clarify"])
|
|
def test_late_409_after_focus_retries_once_and_shows_pending(kind):
|
|
r = _run_late_409_after_focus(kind, cookie_back=True)
|
|
assert r["api"] == 2, "a 409 for a request that predates focus must be retried once"
|
|
assert r["shown"] == 1, "the pending prompt must be shown after the retry"
|
|
assert r["running"] is True, "polling must keep running after the successful retry"
|
|
|
|
|
|
@pytest.mark.parametrize("kind", ["approval", "clarify"])
|
|
def test_late_409_after_focus_pauses_when_retry_still_mismatches(kind):
|
|
r = _run_late_409_after_focus(kind, cookie_back=False)
|
|
assert r["shown"] == 0
|
|
assert r["running"] is False, "a retry that still mismatches must pause, not loop"
|