37547a7bd1
* test: prove worklog continuity across stream settle * fix: keep settled worklog in place on stream done * fix: preserve settle follow ordering * test: wire settled worklog frame proof * fix: preserve settled worklog detail disclosure * fix: preserve default-open settled worklogs * fix: preserve blank-owner worklogs * fix: keep render fallback self-contained * ci: retrigger hosted checks * style(worklog): grow collapsed Worklog rail tap target to 44px on touch devices (#6454 follow-up) * Release exp-v0.52.171: keep settled Worklog in place across stream settlement (#6454) --------- Co-authored-by: Frank Song <franksong2702@gmail.com> Co-authored-by: nesquena-hermes <nesquena-hermes@users.noreply.github.com>
556 lines
28 KiB
Python
556 lines
28 KiB
Python
"""Regression locks for #4970 round 6: stream-end worklog collapse shrink jump.
|
|
|
|
Round 7 (scoping fix): the keep-open exception must apply to ONLY the turn that
|
|
just settled, gated on a one-shot stream-id token, NOT to every historical
|
|
settled worklog on every re-render.
|
|
|
|
Round 8 (mobile unpinned fix, #MOBILESCROLL follow-up): the keep-open exception
|
|
must also cover the UNPINNED reader who scrolled up to read inside the
|
|
just-settled turn. The earlier round scoped keep-open to pinned followers only,
|
|
on the assumption that unpinned readers "preserve their viewport normally". That
|
|
holds on desktop (overflow-anchor:none + JS snapshot restore) but NOT on mobile:
|
|
the CSS resting value is overflow-anchor:auto and _fixMobileScrollJank() flips an
|
|
inline overflow-anchor:none over the settle render, so native anchoring is
|
|
suppressed during the one frame the unpinned reader needs it to absorb the
|
|
above-viewport worklog shrink — the content leaps to the top of the turn (the
|
|
"往回大跳" report). Keeping the just-settled worklog open removes the shrink for
|
|
every device/anchor-mode, so the helper now returns true for the armed turn
|
|
regardless of pin state.
|
|
|
|
These tests are BEHAVIORAL: they extract the real
|
|
`_shouldKeepSettledWorklogOpenForStreamSettle` helper plus its arm/disarm token
|
|
API from static/ui.js and execute them in Node, then drive two settled turns and
|
|
assert the second (historical) turn collapses while the just-settled one stays
|
|
open for both pin states.
|
|
"""
|
|
import json
|
|
import shutil
|
|
import subprocess
|
|
import textwrap
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
UI_JS = (ROOT / "static" / "ui.js").read_text(encoding="utf-8")
|
|
MESSAGES_JS = (ROOT / "static" / "messages.js").read_text(encoding="utf-8")
|
|
|
|
|
|
def _function_body(src: str, name: str) -> str:
|
|
marker = f"function {name}"
|
|
start = src.index(marker)
|
|
brace = src.index("{", start)
|
|
depth = 0
|
|
for idx in range(brace, len(src)):
|
|
ch = src[idx]
|
|
if ch == "{":
|
|
depth += 1
|
|
elif ch == "}":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return src[brace + 1 : idx]
|
|
raise AssertionError(f"function {name} body not found")
|
|
|
|
|
|
def _extract(name: str) -> str:
|
|
"""Return the full `function name(...){...}` text from ui.js."""
|
|
marker = f"function {name}"
|
|
start = UI_JS.index(marker)
|
|
body = _function_body(UI_JS, name)
|
|
sig = UI_JS[start : UI_JS.index("{", start)]
|
|
return f"{sig}{{{body}}}"
|
|
|
|
|
|
def test_helper_and_token_threaded_through_render():
|
|
# Structural: the helper takes a streamId and gates on the one-shot token,
|
|
# and the call site threads the message's stream id (not a no-arg call).
|
|
helper = _function_body(UI_JS, "_shouldKeepSettledWorklogOpenForStreamSettle")
|
|
assert "_keepSettledWorklogOpenForStreamId" in helper
|
|
# Round 8: the helper must NOT re-narrow to pinned-only — keep-open now covers
|
|
# the unpinned reader too, so the pin-state gate is gone from the return.
|
|
assert "_scrollPinned" not in helper, (
|
|
"keep-open must apply to the just-settled turn regardless of pin state "
|
|
"(unpinned mobile readers also get the shrink jump); do not gate on "
|
|
"_scrollPinned/_messageUserUnpinned."
|
|
)
|
|
render_fn = _function_body(UI_JS, "_renderSettledAnchorSceneForMessage")
|
|
assert "_shouldKeepSettledWorklogOpenForStreamSettle(streamId)" in render_fn
|
|
# keepSettledWorklogOpen must still drive the settled-render collapsed flag.
|
|
# #5941 OR'd in an errored-turn keep-open term, so the expression is now
|
|
# `collapsed:!(keepSettledWorklogOpen||erroredWorklogKeepOpen)` — assert the
|
|
# invariant (keepSettledWorklogOpen negates into `collapsed`) without pinning
|
|
# the exact term list.
|
|
assert "collapsed:!(keepSettledWorklogOpen" in render_fn
|
|
group_fn = _function_body(UI_JS, "_anchorSceneWorklogGroup")
|
|
assert "collapsed:(opts&&opts.collapsed!==undefined)?opts.collapsed:!live" in group_fn
|
|
# The STREAM_DONE handler arms one-shot then disarms around the render.
|
|
assert "_armKeepSettledWorklogOpen(_settledStreamId)" in MESSAGES_JS
|
|
assert "_disarmKeepSettledWorklogOpen()" in MESSAGES_JS
|
|
|
|
|
|
@pytest.mark.skipif(shutil.which("node") is None, reason="node required for behavioral test")
|
|
def test_just_settled_turn_stays_open_for_both_pin_states_history_collapses():
|
|
"""Only the just-settled turn stays open; it does so for pinned AND unpinned."""
|
|
helper = _extract("_shouldKeepSettledWorklogOpenForStreamSettle")
|
|
arm = _extract("_armKeepSettledWorklogOpen")
|
|
disarm = _extract("_disarmKeepSettledWorklogOpen")
|
|
harness = textwrap.dedent(f"""
|
|
let _keepSettledWorklogOpenForStreamId=null;
|
|
let _scrollPinned=true, _messageUserUnpinned=false; // pinned follower
|
|
{helper}
|
|
{arm}
|
|
{disarm}
|
|
const out={{}};
|
|
// Turn A just settled: arm A, render A (open), render historical B (collapsed), disarm.
|
|
_armKeepSettledWorklogOpen('streamA');
|
|
out.A_open_pinned = _shouldKeepSettledWorklogOpenForStreamSettle('streamA'); // expect true
|
|
out.B_history = _shouldKeepSettledWorklogOpenForStreamSettle('streamB'); // expect false
|
|
// Round 8: an UNPINNED reader of the just-settled turn must ALSO keep it open
|
|
// (the mobile above-viewport shrink jump). This is the behavior change.
|
|
_messageUserUnpinned=true; _scrollPinned=false;
|
|
out.A_open_unpinned = _shouldKeepSettledWorklogOpenForStreamSettle('streamA'); // expect true
|
|
out.B_history_unpinned = _shouldKeepSettledWorklogOpenForStreamSettle('streamB'); // expect false
|
|
_disarmKeepSettledWorklogOpen();
|
|
// After disarm, even A collapses on a later re-render (one-shot scope intact).
|
|
out.A_after_disarm = _shouldKeepSettledWorklogOpenForStreamSettle('streamA'); // false
|
|
// No token at all → never keep open.
|
|
out.no_token = _shouldKeepSettledWorklogOpenForStreamSettle(''); // false
|
|
console.log(JSON.stringify(out));
|
|
""")
|
|
res = subprocess.run(["node", "-e", harness], capture_output=True, text=True, timeout=30)
|
|
assert res.returncode == 0, res.stderr
|
|
out = json.loads(res.stdout.strip())
|
|
assert out["A_open_pinned"] is True, "just-settled turn must keep worklog open for pinned follower"
|
|
assert out["A_open_unpinned"] is True, (
|
|
"just-settled turn must ALSO keep worklog open for an unpinned reader — "
|
|
"the above-viewport collapse shrink janks them to the turn top on mobile"
|
|
)
|
|
assert out["B_history"] is False, "historical settled worklog must stay collapsed (pinned)"
|
|
assert out["B_history_unpinned"] is False, "historical settled worklog must stay collapsed (unpinned)"
|
|
assert out["A_after_disarm"] is False, "exception must be one-shot, cleared after the render"
|
|
assert out["no_token"] is False, "no armed stream id → never keep open"
|
|
|
|
|
|
def test_forced_open_dom_is_not_cached_while_token_armed():
|
|
# Round 9 (#5260 gate-cert, RED): the keep-open settle render force-opens the
|
|
# worklog; that DOM must NOT be written into _sessionHtmlCache while the token
|
|
# is armed, or it persists the forced-open worklog across session switches /
|
|
# restores and silently overrides a user-collapsed worklog.
|
|
armed = _function_body(UI_JS, "_isKeepSettledWorklogOpenArmed")
|
|
assert "_keepSettledWorklogOpenForStreamId!==null" in armed, (
|
|
"_isKeepSettledWorklogOpenArmed() must report whether the one-shot "
|
|
"keep-open token is currently armed."
|
|
)
|
|
# The cache-write guard in renderMessages must consult the armed check (via a
|
|
# typeof-safe local) so the forced-open settle render is excluded from
|
|
# _sessionHtmlCache.set().
|
|
assert "typeof _isKeepSettledWorklogOpenArmed==='function'" in UI_JS, (
|
|
"the cache guard must call _isKeepSettledWorklogOpenArmed() through a "
|
|
"typeof check so standalone renderMessages() harnesses still work (#5260)."
|
|
)
|
|
assert "!_keepOpenArmed" in UI_JS, (
|
|
"the _sessionHtmlCache population guard must include !_keepOpenArmed so the "
|
|
"forced-open settle render DOM is not cached (#5260)."
|
|
)
|
|
# Anchor it to the actual cache-write site: the armed check sits on the same
|
|
# condition as the INFLIGHT / transient-UI guards that gate the cache .set().
|
|
cache_guard_idx = UI_JS.index("!_keepOpenArmed")
|
|
window = UI_JS[cache_guard_idx : cache_guard_idx + 400]
|
|
assert "_sessionHtmlCache.set(" in window, (
|
|
"the !_keepOpenArmed guard must gate the "
|
|
"_sessionHtmlCache.set() call, not some unrelated branch."
|
|
)
|
|
|
|
|
|
def test_stream_done_collapses_in_place_after_disarm_with_render_fallback():
|
|
# Round 9 (#5260 gate-cert, RED x2): disarming the token alone leaves the
|
|
# forced-open worklog on screen. The first re-push collapse-rendered only the
|
|
# NON-following path and let a pinned follower fall through to scrollToBottom()
|
|
# — but scrollToBottom() does NOT re-render (ui.js), so the armed-open DOM
|
|
# persisted for pinned followers. Fix: run the scroll-PRESERVING collapse pass
|
|
# UNCONDITIONALLY right after disarm (covers both pin states), THEN scrollToBottom()
|
|
# only for followers to re-settle at the tail. This makes keep-open genuinely
|
|
# one-frame for everyone.
|
|
#
|
|
# Round 10 (#6385): capture the scroll snapshot from the LIVE DOM before arming
|
|
# keep-open, so the collapse render below anchors to the content the reader was
|
|
# actually viewing — not to a stale intermediate state where the worklog was
|
|
# temporarily expanded. The pre-capture variable must be defined before arm and
|
|
# threaded into the collapse pass as `_prescrollSnapshot`.
|
|
pre_capture_idx = MESSAGES_JS.index("_doneLiveScrollSnapshot")
|
|
arm_idx = MESSAGES_JS.index("_armKeepSettledWorklogOpen")
|
|
assert pre_capture_idx < arm_idx, (
|
|
"_doneLiveScrollSnapshot must be captured before _armKeepSettledWorklogOpen "
|
|
"to snapshot the live (not expanded-worklog) DOM positions."
|
|
)
|
|
disarm_idx = MESSAGES_JS.index("_disarmKeepSettledWorklogOpen()")
|
|
after = MESSAGES_JS[disarm_idx : disarm_idx + 1100]
|
|
# #6414: the preferred collapse is now in-place. The old second full
|
|
# transcript render remains only as a fail-closed fallback when the exact
|
|
# settled Worklog cannot be identified or collapsed.
|
|
assert "_collapseJustSettledWorklogInPlace" in after
|
|
assert "&& _collapseJustSettledWorklogInPlace(_settledStreamId)" in after, (
|
|
"after _disarmKeepSettledWorklogOpen() the STREAM_DONE handler must first "
|
|
"collapse the just-settled Worklog in place, avoiding a second transcript "
|
|
"rebuild that removes the freshly-settled DOM."
|
|
)
|
|
assert "_restoreMessageScrollSnapshotSameFrame(_doneLiveScrollSnapshot)" in after, (
|
|
"the in-place collapse path must still restore the pre-captured live scroll "
|
|
"snapshot so pinned and unpinned readers keep their viewport."
|
|
)
|
|
assert "_renderMessagesWithScrollSnapshot({_prescrollSnapshot:_doneLiveScrollSnapshot})" in after, (
|
|
"if in-place collapse cannot prove it owns the exact settled Worklog, the "
|
|
"STREAM_DONE handler must fall back to the old scroll-preserving render pass."
|
|
)
|
|
# The follower re-settle (scrollToBottom) must come AFTER the collapse/fallback
|
|
# handling; otherwise a pinned follower can keep the forced-open DOM
|
|
# (scrollToBottom does not re-render).
|
|
collapse_pos = after.index("_collapseJustSettledWorklogInPlace")
|
|
fallback_pos = after.index("_renderMessagesWithScrollSnapshot")
|
|
follow_pos = after.index("shouldFollowOnDone")
|
|
assert collapse_pos < follow_pos, (
|
|
"the in-place collapse must run BEFORE the shouldFollowOnDone scrollToBottom() "
|
|
"so BOTH pinned and unpinned readers get the worklog collapsed; scrollToBottom() "
|
|
"alone does not re-render and would leave a pinned follower forced-open."
|
|
)
|
|
assert fallback_pos < follow_pos, (
|
|
"the fallback render pass must also stay before shouldFollowOnDone so the "
|
|
"fail-closed path preserves the prior #5260 invariant."
|
|
)
|
|
assert "scrollToBottom()" in after, (
|
|
"a pinned/near-bottom follower must scrollToBottom() after the collapse "
|
|
"handling to re-settle exactly at the tail."
|
|
)
|
|
# And the wrapper must exist and be scroll-preserving (capture → render →
|
|
# restore same-frame), so the collapse height change is absorbed by the JS
|
|
# restore rather than left to native scroll-anchoring (suppressed on mobile).
|
|
wrapper = _function_body(UI_JS, "_renderMessagesWithScrollSnapshot")
|
|
assert "_captureMessageScrollSnapshot()" in wrapper
|
|
assert "_restoreMessageScrollSnapshotSameFrame" in wrapper
|
|
|
|
|
|
def test_in_place_settled_worklog_collapse_defers_rows_without_full_rebuild():
|
|
body = _function_body(UI_JS, "_collapseJustSettledWorklogInPlace")
|
|
assert "_assistantTurnHasVisibleRenderedSegment(ownerTurn)" in body
|
|
assert "if(ownerHasVisibleSegment===null) return false" in body
|
|
assert "const keepOpen=!ownerHasVisibleSegment" in body
|
|
assert "[data-anchor-settled-scene-owner=\"1\"]" in body
|
|
assert "data-anchor-stream-id" in body
|
|
assert "_deferredWorklogRowsFromGroup(group)" in body
|
|
assert "_captureWorklogDetailDisclosureState(group)" in body
|
|
assert "_worklogDetailsExpandedDefault()&&savedDisclosure!=='closed'" in body
|
|
assert "group._deferredWorklogRows=rows" in body
|
|
assert "group._deferredWorklogDisclosure=detailDisclosure&&detailDisclosure.size" in body
|
|
assert "data-worklog-rows-deferred" in body
|
|
assert "tool-call-group-collapsed" in body
|
|
assert "_syncToolCallGroupSummary(group)" in body
|
|
assert "requestAnimationFrame" in body
|
|
assert "list.replaceChildren()" in body
|
|
assert "renderMessages(" not in body
|
|
|
|
|
|
@pytest.mark.skipif(shutil.which("node") is None, reason="node required for behavioral test")
|
|
def test_done_defers_live_dom_removal_but_other_terminal_paths_still_clear():
|
|
"""The normal done handoff must not expose an empty live-worklog frame.
|
|
|
|
The settled transcript render owns replacement of the live DOM. Calling the
|
|
shared cleanup helper in preserve-DOM mode may stop timers and reset intent,
|
|
but must leave the visible rows in place until that replacement occurs.
|
|
Default cleanup remains destructive for error/cancel paths.
|
|
"""
|
|
clear_live = _extract("clearLiveToolCards")
|
|
done_start = MESSAGES_JS.index("source.addEventListener('done',e=>{")
|
|
done = MESSAGES_JS[done_start : done_start + 14000]
|
|
harness = textwrap.dedent(f"""
|
|
let removed = 0;
|
|
let timerClears = 0;
|
|
let intentClears = 0;
|
|
const rows = [{{remove() {{ removed++; }}}}, {{remove() {{ removed++; }}}}];
|
|
const inner = {{querySelectorAll() {{ return rows; }}}};
|
|
const legacy = {{innerHTML: 'legacy', style: {{display: ''}}}};
|
|
globalThis._clearActivityElapsedTimer = () => {{ timerClears++; }};
|
|
globalThis._clearLiveActivityUserIntent = () => {{ intentClears++; }};
|
|
globalThis._assistantTurnBlocks = () => inner;
|
|
globalThis.$ = (id) => id === 'liveAssistantTurn' ? {{}} : id === 'liveToolCards' ? legacy : null;
|
|
{clear_live}
|
|
clearLiveToolCards({{preserveDom: true}});
|
|
const preserved = {{removed, timerClears, intentClears, legacy: legacy.innerHTML, legacyDisplay: legacy.style.display}};
|
|
clearLiveToolCards();
|
|
const defaultCleared = {{removed, timerClears, intentClears, legacy: legacy.innerHTML, legacyDisplay: legacy.style.display}};
|
|
console.log(JSON.stringify({{preserved, defaultCleared}}));
|
|
""")
|
|
res = subprocess.run(["node", "-e", harness], capture_output=True, text=True, timeout=30)
|
|
assert res.returncode == 0, res.stderr
|
|
out = json.loads(res.stdout.strip())
|
|
assert out["preserved"] == {
|
|
"removed": 0,
|
|
"timerClears": 1,
|
|
"intentClears": 1,
|
|
"legacy": "",
|
|
"legacyDisplay": "none",
|
|
}, "preserveDom cleanup must leave the live worklog visible until the settled render replaces it"
|
|
assert out["defaultCleared"]["removed"] == 2, "error/cancel cleanup must still remove live rows"
|
|
assert out["defaultCleared"]["legacy"] == "", "default cleanup must still clear the legacy container"
|
|
assert out["defaultCleared"]["legacyDisplay"] == "none", "legacy cleanup must hide the container"
|
|
assert "clearLiveToolCards({preserveDom:true})" in done, (
|
|
"the normal done handler must preserve the visible live Worklog until its "
|
|
"settled transcript render replaces it"
|
|
)
|
|
|
|
|
|
@pytest.mark.skipif(shutil.which("node") is None, reason="node required for behavioral test")
|
|
def test_in_place_collapse_preserves_detail_disclosure_for_deferred_materialize():
|
|
"""A just-settled in-place collapse must preserve nested detail open state.
|
|
|
|
The old full render path captured Worklog detail disclosure before rebuilding
|
|
and stashed that map on deferred groups. The new in-place path must do the
|
|
same before its rAF removes the rendered rows; otherwise a live-open tool
|
|
detail is lost when the user expands the collapsed settled Worklog.
|
|
"""
|
|
collapse = _extract("_collapseJustSettledWorklogInPlace")
|
|
visible_segment = _extract("_assistantTurnHasVisibleRenderedSegment")
|
|
materialize = _extract("_materializeDeferredWorklogRows")
|
|
harness = textwrap.dedent(f"""
|
|
const assert = require('assert');
|
|
const rows = [{{id: 'row-1'}}];
|
|
let activeGroup = null;
|
|
let capturedGroup = null;
|
|
let renderedRows = null;
|
|
let restoredState = null;
|
|
let removedRows = false;
|
|
let syncCount = 0;
|
|
let ownerHasVisibleSegment = true;
|
|
const S = {{
|
|
session: {{session_id: 'session-1'}},
|
|
// Keep the session-wide no-response guard false: a normal answered
|
|
// turn precedes the completed tool/reasoning-only turn under test.
|
|
messages: [
|
|
{{role: 'assistant', content: 'previous final answer'}},
|
|
{{role: 'assistant', content: '', _anchor_activity_scene: {{terminal_state: 'completed'}}}},
|
|
],
|
|
}};
|
|
const summary = {{
|
|
attrs: {{}},
|
|
setAttribute(name, value) {{ this.attrs[name] = String(value); }},
|
|
}};
|
|
const list = {{
|
|
replaceChildren() {{ removedRows = true; }},
|
|
}};
|
|
const inner = {{
|
|
querySelectorAll(selector) {{
|
|
if (selector === '[data-anchor-settled-scene-owner="1"]') return [activeGroup];
|
|
return [];
|
|
}},
|
|
}};
|
|
const visibleSegment = {{
|
|
textContent: 'previous final answer',
|
|
classList: {{ contains() {{ return false; }} }},
|
|
}};
|
|
const ownerTurn = {{
|
|
querySelectorAll(selector) {{
|
|
assert.strictEqual(selector, '.assistant-segment');
|
|
return ownerHasVisibleSegment ? [visibleSegment] : [];
|
|
}},
|
|
}};
|
|
function makeGroup() {{
|
|
return {{
|
|
attrs: {{
|
|
'data-anchor-stream-id': 'stream-1',
|
|
'data-activity-disclosure-key': 'anchor-scene:1',
|
|
}},
|
|
isConnected: true,
|
|
_deferredWorklogRows: null,
|
|
_deferredWorklogDisclosure: 'stale',
|
|
closest(selector) {{
|
|
assert.strictEqual(selector, '.assistant-turn');
|
|
return ownerTurn;
|
|
}},
|
|
getAttribute(name) {{ return this.attrs[name] || ''; }},
|
|
setAttribute(name, value) {{ this.attrs[name] = String(value); }},
|
|
removeAttribute(name) {{ delete this.attrs[name]; }},
|
|
querySelector(selector) {{
|
|
if (selector.includes('tool-worklog-summary') || selector.includes('tool-call-group-summary')) return summary;
|
|
return null;
|
|
}},
|
|
querySelectorAll() {{ return []; }},
|
|
classList: {{
|
|
values: new Set(['open']),
|
|
add(name) {{ this.values.add(name); }},
|
|
remove(name) {{ this.values.delete(name); }},
|
|
contains(name) {{ return this.values.has(name); }},
|
|
}},
|
|
}};
|
|
}}
|
|
function $(id) {{ return id === 'msgInner' ? inner : null; }}
|
|
function _readActivityDisclosureState() {{ return detailState; }}
|
|
function _deferredWorklogRowsFromGroup(group) {{ assert.strictEqual(group, activeGroup); return rows; }}
|
|
function _anchorSceneHasErroredTerminalState() {{ return false; }}
|
|
function _syncToolCallGroupSummary(group) {{ assert.strictEqual(group, activeGroup); syncCount += 1; }}
|
|
function _toolWorklogListEl(group) {{ assert.strictEqual(group, activeGroup); return list; }}
|
|
function _renderAnchorSceneRowsIntoWorklog(group, materializedRows) {{
|
|
assert.strictEqual(group, activeGroup);
|
|
renderedRows = materializedRows;
|
|
return true;
|
|
}}
|
|
function _postProcessWithAnchorSuppression() {{}}
|
|
function _restoreWorklogDetailDisclosureState(group, state) {{
|
|
assert.strictEqual(group, activeGroup);
|
|
restoredState = state;
|
|
}}
|
|
function requestAnimationFrame(callback) {{ callback(); }}
|
|
let detailState = null;
|
|
let defaultExpanded = false;
|
|
function _captureWorklogDetailDisclosureState(group) {{
|
|
capturedGroup = group;
|
|
return detailState;
|
|
}}
|
|
function _worklogDetailsExpandedDefault() {{ return defaultExpanded; }}
|
|
{visible_segment}
|
|
{collapse}
|
|
{materialize}
|
|
|
|
activeGroup = makeGroup();
|
|
detailState = new Map([['tool:read_file#0', {{open: true, scrollTop: 18}}]]);
|
|
assert.strictEqual(_collapseJustSettledWorklogInPlace('stream-1'), true);
|
|
assert.strictEqual(capturedGroup, activeGroup);
|
|
assert.strictEqual(activeGroup._deferredWorklogDisclosure, detailState);
|
|
assert.strictEqual(activeGroup._deferredWorklogRows, rows);
|
|
assert.strictEqual(activeGroup.attrs['data-worklog-rows-deferred'], '1');
|
|
assert.strictEqual(activeGroup.classList.contains('tool-call-group-collapsed'), true);
|
|
assert.strictEqual(removedRows, true);
|
|
assert.strictEqual(_materializeDeferredWorklogRows(activeGroup), true);
|
|
assert.strictEqual(restoredState, detailState);
|
|
assert.strictEqual(renderedRows, rows);
|
|
|
|
capturedGroup = null;
|
|
renderedRows = null;
|
|
restoredState = null;
|
|
removedRows = false;
|
|
activeGroup = makeGroup();
|
|
detailState = new Map();
|
|
assert.strictEqual(_collapseJustSettledWorklogInPlace('stream-1'), true);
|
|
assert.strictEqual(capturedGroup, activeGroup);
|
|
assert.strictEqual(activeGroup._deferredWorklogDisclosure, null);
|
|
assert.strictEqual(_materializeDeferredWorklogRows(activeGroup), true);
|
|
assert.strictEqual(restoredState, null);
|
|
assert.strictEqual(renderedRows, rows);
|
|
assert.strictEqual(syncCount, 2);
|
|
|
|
removedRows = false;
|
|
activeGroup = makeGroup();
|
|
detailState = null;
|
|
defaultExpanded = true;
|
|
ownerHasVisibleSegment = true;
|
|
assert.strictEqual(_collapseJustSettledWorklogInPlace('stream-1'), true);
|
|
assert.strictEqual(activeGroup._deferredWorklogRows, null);
|
|
assert.strictEqual(activeGroup.classList.contains('open'), true);
|
|
assert.strictEqual(activeGroup.classList.contains('tool-call-group-collapsed'), false);
|
|
assert.strictEqual(removedRows, false);
|
|
|
|
activeGroup = makeGroup();
|
|
detailState = 'closed';
|
|
ownerHasVisibleSegment = true;
|
|
assert.strictEqual(_collapseJustSettledWorklogInPlace('stream-1'), true);
|
|
assert.strictEqual(activeGroup._deferredWorklogRows, rows);
|
|
assert.strictEqual(activeGroup.classList.contains('tool-call-group-collapsed'), true);
|
|
assert.strictEqual(removedRows, true);
|
|
|
|
removedRows = false;
|
|
activeGroup = makeGroup();
|
|
detailState = 'closed';
|
|
defaultExpanded = false;
|
|
ownerHasVisibleSegment = false;
|
|
assert.strictEqual(_collapseJustSettledWorklogInPlace('stream-1'), true);
|
|
assert.strictEqual(activeGroup._deferredWorklogRows, null);
|
|
assert.strictEqual(activeGroup.classList.contains('open'), true);
|
|
assert.strictEqual(activeGroup.classList.contains('tool-call-group-collapsed'), false);
|
|
assert.strictEqual(removedRows, false);
|
|
console.log(JSON.stringify({{ok: true}}));
|
|
""")
|
|
res = subprocess.run(["node", "-e", harness], capture_output=True, text=True, timeout=30)
|
|
assert res.returncode == 0, res.stderr
|
|
assert json.loads(res.stdout.strip()) == {"ok": True}
|
|
|
|
|
|
@pytest.mark.skipif(shutil.which("node") is None, reason="node required for behavioral test")
|
|
def test_prescroll_snapshot_bypasses_capture_no_option_fallback_still_captures():
|
|
"""Sentinel _prescrollSnapshot reaches restore without re-capture.
|
|
|
|
Behavioral harness for _renderMessagesWithScrollSnapshot:
|
|
|
|
1. Supply a sentinel snapshot via _prescrollSnapshot, stub
|
|
_captureMessageScrollSnapshot with a counter — proves the
|
|
sentinel reaches _restoreMessageScrollSnapshotSameFrame
|
|
without a second capture.
|
|
|
|
2. Call with no options — proves the no-option fallback still
|
|
calls _captureMessageScrollSnapshot() normally (the contract
|
|
for callers at static/ui.js:9565, 14416, 14424).
|
|
|
|
3. Call with empty options {} — same fallback proof.
|
|
"""
|
|
wrapper = _extract("_renderMessagesWithScrollSnapshot")
|
|
harness = textwrap.dedent(f"""
|
|
let captureCount = 0;
|
|
let restoredSnapshot = null;
|
|
let renderedOptions = null;
|
|
globalThis._captureMessageScrollSnapshot = () => {{
|
|
captureCount++;
|
|
return {{_sentinel: 'fresh-capture', bottom: 0, pinned: true}};
|
|
}};
|
|
globalThis.renderMessages = (opts) => {{ renderedOptions = opts; }};
|
|
globalThis._restoreMessageScrollSnapshotSameFrame = (snap) => {{ restoredSnapshot = snap; }};
|
|
{wrapper}
|
|
// Test 1: supplied _prescrollSnapshot -> use it, do NOT capture
|
|
const sentinel = {{_sentinel: 'pre-captured', bottom: 42, pinned: true}};
|
|
_renderMessagesWithScrollSnapshot({{_prescrollSnapshot: sentinel}});
|
|
const test1_usedPrescroll = restoredSnapshot === sentinel;
|
|
const test1_noCapture = captureCount === 0;
|
|
const test1_preservedArgs = renderedOptions && renderedOptions._prescrollSnapshot === sentinel;
|
|
// Reset
|
|
captureCount = 0; restoredSnapshot = null; renderedOptions = null;
|
|
// Test 2: no options -> fall back to _captureMessageScrollSnapshot()
|
|
_renderMessagesWithScrollSnapshot();
|
|
const test2_captured = captureCount === 1;
|
|
const test2_usedCapture = restoredSnapshot && restoredSnapshot._sentinel === 'fresh-capture';
|
|
// Reset
|
|
captureCount = 0; restoredSnapshot = null; renderedOptions = null;
|
|
// Test 3: empty options object -> still fall back to capture
|
|
_renderMessagesWithScrollSnapshot({{}});
|
|
const test3_captured = captureCount === 1;
|
|
const test3_usedCapture = restoredSnapshot && restoredSnapshot._sentinel === 'fresh-capture';
|
|
console.log(JSON.stringify({{
|
|
test1_usedPrescroll,
|
|
test1_noCapture,
|
|
test1_preservedArgs,
|
|
test2_captured,
|
|
test2_usedCapture,
|
|
test3_captured,
|
|
test3_usedCapture
|
|
}}));
|
|
""")
|
|
res = subprocess.run(["node", "-e", harness], capture_output=True, text=True, timeout=30)
|
|
assert res.returncode == 0, res.stderr
|
|
out = json.loads(res.stdout.strip())
|
|
assert out["test1_usedPrescroll"] is True, (
|
|
"supplied _prescrollSnapshot must reach _restoreMessageScrollSnapshotSameFrame"
|
|
)
|
|
assert out["test1_noCapture"] is True, (
|
|
"supplied _prescrollSnapshot must bypass _captureMessageScrollSnapshot()"
|
|
)
|
|
assert out["test1_preservedArgs"] is True, (
|
|
"options passed to _renderMessagesWithScrollSnapshot must be forwarded to renderMessages"
|
|
)
|
|
assert out["test2_captured"] is True, (
|
|
"no-option call must fall back to _captureMessageScrollSnapshot()"
|
|
)
|
|
assert out["test2_usedCapture"] is True, (
|
|
"no-option call's captured snapshot must reach _restoreMessageScrollSnapshotSameFrame"
|
|
)
|
|
assert out["test3_captured"] is True, (
|
|
"empty-options call must fall back to _captureMessageScrollSnapshot()"
|
|
)
|
|
assert out["test3_usedCapture"] is True, (
|
|
"empty-options call's captured snapshot must reach _restoreMessageScrollSnapshotSameFrame"
|
|
)
|