@cnrai/pave 0.3.32 → 0.3.34

package/test/tui-compaction.test.js

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+/**
+ * Tests for TUI attached mode compaction fix (Issue #255)
+ *
+ * Verifies:
+ * - STATUS_POLL_INTERVAL reduced to 2000ms
+ * - fetchHistory() called after session compaction detection
+ * - chatBox.setContent('') called before fetchHistory (clears old messages)
+ * - SSE reconnection still happens on compaction
+ *
+ * Designed to run standalone: node test/tui-compaction.test.js
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, msg) {
+  if (!condition) throw new Error('Assertion failed: ' + msg);
+}
+
+function runTest(name, fn) {
+  try {
+    fn();
+    console.log('\u2705 ' + name);
+    passed++;
+  } catch (e) {
+    console.log('\u274C ' + name + ': ' + e.message);
+    failed++;
+  }
+}
+
+// Read the attached.js source for inspection tests
+const attachedPath = path.join(__dirname, '..', '..', 'tui', 'attached.js');
+const attachedSource = fs.readFileSync(attachedPath, 'utf8');
+
+// ============================================================
+// 1. STATUS_POLL_INTERVAL
+// ============================================================
+
+runTest('STATUS_POLL_INTERVAL is 2000ms (not 5000ms)', () => {
+  assert(attachedSource.indexOf('STATUS_POLL_INTERVAL = 2000') !== -1,
+    'should set STATUS_POLL_INTERVAL to 2000');
+  assert(attachedSource.indexOf('STATUS_POLL_INTERVAL = 5000') === -1,
+    'should not have old 5000ms value');
+});
+
+runTest('STATUS_POLL_INTERVAL has explanatory comment', () => {
+  const idx = attachedSource.indexOf('STATUS_POLL_INTERVAL');
+  const section = attachedSource.substring(Math.max(0, idx - 100), idx + 50);
+  assert(section.indexOf('compaction') !== -1 || section.indexOf('responsive') !== -1,
+    'should have a comment explaining why 2s was chosen');
+});
+
+// ============================================================
+// 2. Compaction detection block
+// ============================================================
+
+runTest('compaction block detects session change', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should compare sessionId to currentSessionId');
+  // The compaction marker should exist in the block
+  const section = attachedSource.substring(idx, idx + 2000);
+  assert(section.indexOf('Session compacted') !== -1,
+    'should have Session compacted message');
+});
+
+runTest('compaction block disconnects then reconnects SSE', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2500);
+  assert(section.indexOf('sseConnection.destroy()') !== -1,
+    'should destroy existing SSE connection');
+  assert(section.indexOf('connectSSE()') !== -1,
+    'should call connectSSE() to reconnect');
+});
+
+runTest('compaction block clears chat before fetching history', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2000);
+
+  let clearIdx = section.indexOf("chatBox.setContent('')");
+  if (clearIdx === -1) clearIdx = section.indexOf('chatBox.setContent("")');
+  assert(clearIdx !== -1, 'should call chatBox.setContent("") to clear old messages');
+
+  const fetchIdx = section.indexOf('fetchHistory(');
+  assert(fetchIdx !== -1, 'should call fetchHistory to load new session content');
+
+  // setContent must come BEFORE fetchHistory
+  assert(clearIdx < fetchIdx,
+    'chatBox.setContent should be called before fetchHistory()');
+});
+
+runTest('compaction block calls connectSSE inside fetchHistory callback', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2500);
+
+  // connectSSE should be inside the fetchHistory callback
+  const fetchIdx = section.indexOf('fetchHistory(');
+  const hasCallback = section.indexOf('fetchHistory(function') !== -1
+    || section.indexOf('fetchHistory((') !== -1
+    || section.indexOf('fetchHistory(() =>') !== -1;
+  const sseIdx = section.indexOf('connectSSE()', fetchIdx);
+  assert(hasCallback, 'should call fetchHistory with onComplete callback');
+  assert(sseIdx !== -1, 'should call connectSSE inside the callback');
+  assert(fetchIdx < sseIdx,
+    'connectSSE should be inside fetchHistory callback to wait for history to load');
+});
+
+runTest('compaction block updates currentSessionId before SSE disconnect', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 1000);
+
+  const updateIdx = section.indexOf('currentSessionId = newSessionId');
+  const destroyIdx = section.indexOf('sseConnection.destroy()');
+  assert(updateIdx !== -1, 'should update currentSessionId');
+  assert(destroyIdx !== -1, 'should destroy old SSE');
+  assert(updateIdx < destroyIdx,
+    'currentSessionId should be updated before SSE disconnect');
+});
+
+runTest('compaction marker added inside fetchHistory callback (after history loads)', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2000);
+
+  // The marker should be inside the fetchHistory callback, not before it
+  const callbackIdx = section.indexOf('fetchHistory(');
+  const hasCallback = section.indexOf('fetchHistory(function') !== -1
+    || section.indexOf('fetchHistory((') !== -1
+    || section.indexOf('fetchHistory(() =>') !== -1;
+  assert(hasCallback, 'should have fetchHistory with callback');
+  const callbackSection = section.substring(callbackIdx);
+  assert(callbackSection.indexOf('Session compacted') !== -1,
+    'compaction marker should be inside fetchHistory callback so it persists after history render');
+});
+
+runTest('compaction block resets streaming state', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2000);
+  assert(section.indexOf('streamingActive = false') !== -1,
+    'should reset streamingActive to false');
+  assert(section.indexOf("streamingRawText = ''") !== -1,
+    'should clear streamingRawText');
+  assert(section.indexOf("streamingContentStart = ''") !== -1,
+    'should clear streamingContentStart');
+});
+
+runTest('compaction block resets streaming before clearing chat', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2000);
+  const resetIdx = section.indexOf('streamingActive = false');
+  let clearIdx = section.indexOf("chatBox.setContent('')");
+  if (clearIdx === -1) clearIdx = section.indexOf('chatBox.setContent("")');
+  assert(resetIdx !== -1 && clearIdx !== -1,
+    'both streamingActive reset and chatBox clear should exist');
+  assert(resetIdx < clearIdx,
+    'streaming state should be reset before clearing chat content');
+});
+
+// ============================================================
+// 3. fetchHistory function exists and loads messages
+// ============================================================
+
+runTest('fetchHistory function exists with onComplete callback', () => {
+  assert(attachedSource.indexOf('function fetchHistory(onComplete)') !== -1,
+    'should define fetchHistory with onComplete callback parameter');
+});
+
+runTest('fetchHistory fetches from session/message endpoint', () => {
+  const idx = attachedSource.indexOf('function fetchHistory(onComplete)');
+  assert(idx !== -1, 'should find fetchHistory');
+  const section = attachedSource.substring(idx, idx + 500);
+  assert(section.indexOf('/session/') !== -1 && section.indexOf('/message') !== -1,
+    'should fetch from /session/<id>/message endpoint');
+});
+
+runTest('fetchHistory invokes onComplete callback on both paths', () => {
+  const idx = attachedSource.indexOf('function fetchHistory(onComplete)');
+  assert(idx !== -1, 'should find fetchHistory');
+  const section = attachedSource.substring(idx, idx + 2000);
+  let callCount = 0;
+  let searchIdx = 0;
+  while (true) {
+    const found = section.indexOf('onComplete', searchIdx);
+    if (found === -1) break;
+    callCount++;
+    searchIdx = found + 10;
+  }
+  // onComplete should appear at least 3 times: param, error path, success path
+  assert(callCount >= 3,
+    'onComplete should appear in param + error path + success path (found ' + callCount + ')');
+});
+
+runTest('fetchHistory clears fetching message and renders history', () => {
+  const idx = attachedSource.indexOf('function fetchHistory(onComplete)');
+  assert(idx !== -1, 'should find fetchHistory');
+  const section = attachedSource.substring(idx, idx + 2000);
+  assert(section.indexOf("chatBox.setContent('')") !== -1 || section.indexOf('chatBox.setContent("")') !== -1,
+    'should clear chat before rendering messages');
+});
+
+// ============================================================
+// 4. serverUrl change does NOT call fetchHistory (only compaction does)
+// ============================================================
+
+runTest('serverUrl change block does not call fetchHistory', () => {
+  // Find the serverUrl change block
+  const idx = attachedSource.indexOf('st.serverUrl && st.serverUrl !== currentServerUrl');
+  assert(idx !== -1, 'should find serverUrl change detection');
+  // Get section until next closing brace block
+  const section = attachedSource.substring(idx, idx + 300);
+  // Check for any form of fetchHistory call (with or without args)
+  const fetchIdx = section.indexOf('fetchHistory(');
+  // fetchHistory should NOT be in the serverUrl block
+  assert(fetchIdx === -1,
+    'serverUrl change should not call fetchHistory (only compaction triggers history reload)');
+});
+
+// ============================================================
+// 5. Comment quality
+// ============================================================
+
+runTest('compaction block has explanatory comments about SSE timing', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2000);
+  assert(section.indexOf('SSE') !== -1,
+    'should have comment mentioning SSE reconnection timing');
+  assert(section.indexOf('history') !== -1 || section.indexOf('fetchHistory') !== -1,
+    'should mention history loading in comments');
+});
+
+// ============================================================
+// 6. Reconnect timer cancellation on compaction
+// ============================================================
+
+runTest('reconnectTimer variable declared', () => {
+  assert(attachedSource.indexOf('let reconnectTimer = null') !== -1,
+    'should declare reconnectTimer initialized to null');
+});
+
+runTest('scheduleReconnect stores timer handle', () => {
+  const idx = attachedSource.indexOf('function scheduleReconnect()');
+  assert(idx !== -1, 'should find scheduleReconnect function');
+  const section = attachedSource.substring(idx, idx + 500);
+  assert(section.indexOf('reconnectTimer = setTimeout') !== -1,
+    'should store setTimeout handle in reconnectTimer');
+});
+
+runTest('scheduleReconnect clears timer handle on fire', () => {
+  const idx = attachedSource.indexOf('function scheduleReconnect()');
+  assert(idx !== -1, 'should find scheduleReconnect function');
+  const section = attachedSource.substring(idx, idx + 500);
+  assert(section.indexOf('reconnectTimer = null') !== -1,
+    'should set reconnectTimer to null when timer fires');
+});
+
+runTest('compaction cancels pending reconnect timer', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 800);
+  assert(section.indexOf('clearTimeout(reconnectTimer)') !== -1,
+    'should clearTimeout reconnectTimer in compaction block');
+  assert(section.indexOf('reconnecting = false') !== -1,
+    'should reset reconnecting flag when cancelling timer');
+});
+
+runTest('compaction timer cancel comes before SSE disconnect', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 1000);
+  const cancelIdx = section.indexOf('clearTimeout(reconnectTimer)');
+  const destroyIdx = section.indexOf('sseConnection.destroy()');
+  assert(cancelIdx !== -1 && destroyIdx !== -1,
+    'both timer cancel and SSE destroy should exist');
+  assert(cancelIdx < destroyIdx,
+    'timer cancel should happen before SSE disconnect');
+});
+
+// ============================================================
+// 7. Race-condition guard: captured newSessionId + stale callback skip
+// ============================================================
+
+runTest('compaction captures newSessionId before async fetch', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 1600);
+  assert(section.indexOf('const newSessionId = st.sessionId') !== -1
+    || section.indexOf('let newSessionId = st.sessionId') !== -1
+    || section.indexOf('var newSessionId = st.sessionId') !== -1,
+  'should capture st.sessionId into local newSessionId variable');
+  const captureIdx = section.indexOf('newSessionId = st.sessionId');
+  const fetchIdx = section.indexOf('fetchHistory(');
+  assert(captureIdx < fetchIdx,
+    'newSessionId should be captured before fetchHistory is called');
+});
+
+runTest('fetchHistory callback guards against stale session', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 1800);
+  assert(section.indexOf('currentSessionId !== newSessionId') !== -1,
+    'callback should check if currentSessionId still matches newSessionId');
+  assert(section.indexOf('return') !== -1,
+    'should return early if session has moved on');
+});
+
+runTest('compaction marker uses captured newSessionId (not st.sessionId)', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  const section = attachedSource.substring(idx, idx + 2200);
+  // The marker text should use newSessionId, not st.sessionId
+  const markerIdx = section.indexOf('newSessionId.substring(0, 8)');
+  assert(markerIdx !== -1,
+    'compaction marker should use captured newSessionId, not st.sessionId');
+});
+
+// ============================================================
+// 8. Early return prevents fall-through to serverUrl block
+// ============================================================
+
+runTest('compaction block returns early (no fall-through to serverUrl)', () => {
+  const idx = attachedSource.indexOf('st.sessionId !== currentSessionId');
+  assert(idx !== -1, 'should find compaction block');
+  // Find the end of the compaction if-block
+  const section = attachedSource.substring(idx, idx + 2800);
+  // The block should end with 'return;' before the serverUrl check
+  const returnIdx = section.indexOf('return;');
+  const serverUrlIdx = section.indexOf('st.serverUrl && st.serverUrl !== currentServerUrl');
+  assert(returnIdx !== -1, 'should have return statement');
+  assert(serverUrlIdx !== -1, 'should find serverUrl block');
+  assert(returnIdx < serverUrlIdx,
+    'compaction block should return before serverUrl check to prevent concurrent SSE reconnects');
+});
+
+// ============================================================
+// Done
+// ============================================================
+
+console.log('\n' + passed + '/' + (passed + failed) + ' tests passed');
+if (failed > 0) {
+  console.log(failed + ' test(s) FAILED');
+  process.exitCode = 1;
+} else {
+  console.log('All tests passed!');
+}