@cnrai/pave 0.3.33 → 0.3.34

package/test/abort-stream.test.js

@@ -0,0 +1,445 @@
+// Tests for Issue #249: Ctrl+U abort signal wiring to LLM stream
+// Verifies that abort signal is properly passed through the call chain
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function runTest(name, fn) {
+  try {
+    fn();
+    console.log('\u2705 ' + name);
+    passed++;
+  } catch (e) {
+    console.log('\u274C ' + name + ': ' + e.message);
+    failed++;
+  }
+}
+
+// ============================================================
+// Source inspection tests: verify signal wiring is in place
+// ============================================================
+
+const handlerSource = fs.readFileSync(
+  path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'prompt', 'handler.js'), 'utf8');
+const providerSource = fs.readFileSync(
+  path.join(__dirname, '..', '..', 'opencode-lite', 'src', 'provider', 'index.js'), 'utf8');
+
+// --- handler.js tests ---
+
+runTest('handler.js: passes signal to streamResponse()', () => {
+  // Find the streamResponse call and verify it includes signal
+  const streamCallIdx = handlerSource.indexOf('response = await streamResponse({');
+  assert(streamCallIdx !== -1, 'should find streamResponse call');
+  const callSection = handlerSource.substring(streamCallIdx, streamCallIdx + 500);
+  // Match shorthand `signal,` or explicit `signal: signal`
+  assert(callSection.indexOf('signal') !== -1,
+    'streamResponse() call should include signal parameter');
+});
+
+runTest('handler.js: breaks on aborted finish_reason', () => {
+  const pattern = /finishReason\s*===\s*["']aborted["']/;
+  assert(pattern.test(handlerSource),
+    'should check for "aborted" finish reason and break the iteration loop');
+  assert(handlerSource.indexOf('LLM stream was aborted') !== -1,
+    'should log when stream is aborted');
+});
+
+runTest('handler.js: checks signal in executeOneTool', () => {
+  // Find executeOneTool function
+  const fnIdx = handlerSource.indexOf('async function executeOneTool');
+  assert(fnIdx !== -1, 'should find executeOneTool function');
+  const fnSection = handlerSource.substring(fnIdx, fnIdx + 300);
+  assert(fnSection.indexOf('signal && signal.aborted') !== -1,
+    'executeOneTool should check signal.aborted before executing');
+  assert(fnSection.indexOf('Tool execution skipped') !== -1,
+    'should return skip message when aborted');
+});
+
+// --- provider/index.js tests ---
+
+runTest('provider: processStreamingResponse accepts signal parameter', () => {
+  const pattern = /function\s+processStreamingResponse\s*\([^)]*signal[^)]*\)/;
+  assert(pattern.test(providerSource),
+    'processStreamingResponse should accept signal as a parameter');
+});
+
+runTest('provider: processStreamingResponse checks signal.aborted before starting', () => {
+  // Find processStreamingResponse function
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  assert(fnIdx !== -1, 'should find processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 2500);
+  assert(fnSection.indexOf("signal && signal.aborted") !== -1,
+    'should check signal.aborted early');
+  assert(fnSection.indexOf("finish_reason: 'aborted'") !== -1,
+    'should return aborted finish_reason when signal is aborted');
+});
+
+runTest('provider: processStreamingResponse listens for abort event', () => {
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 3000);
+  assert(fnSection.indexOf("signal.addEventListener('abort'") !== -1,
+    'should add event listener for abort signal');
+  assert(fnSection.indexOf("signal.removeEventListener('abort'") !== -1,
+    'should clean up event listener to prevent memory leaks');
+});
+
+runTest('provider: processStreamingResponse destroys reader on abort', () => {
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 3000);
+  // The onAbort handler should destroy the reader
+  const abortHandlerIdx = fnSection.indexOf('onAbort = function ()');
+  assert(abortHandlerIdx !== -1, 'should have onAbort handler');
+  const abortSection = fnSection.substring(abortHandlerIdx, abortHandlerIdx + 500);
+  assert(abortSection.indexOf('reader.destroy()') !== -1,
+    'abort handler should destroy the reader stream');
+});
+
+runTest('provider: streamGitHubCopilotResponseInternal early abort return', () => {
+  const fnIdx = providerSource.indexOf('function streamGitHubCopilotResponseInternal');
+  assert(fnIdx !== -1, 'should find streamGitHubCopilotResponseInternal');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 400);
+  assert(fnSection.indexOf('opts.signal && opts.signal.aborted') !== -1,
+    'should check for already-aborted signal before making fetch call');
+  assert(fnSection.indexOf("finish_reason: 'aborted'") !== -1,
+    'should return aborted result when signal is already aborted');
+});
+
+runTest('provider: fetch() receives signal option', () => {
+  // Find the fetch call in streamGitHubCopilotResponseInternal
+  const fetchIdx = providerSource.indexOf("return fetch(provider.baseUrl");
+  assert(fetchIdx !== -1, 'should find fetch call');
+  const fetchSection = providerSource.substring(fetchIdx, fetchIdx + 500);
+  assert(fetchSection.indexOf('signal: opts.signal') !== -1,
+    'fetch() should receive signal from opts to cancel HTTP request');
+});
+
+runTest('provider: fetch AbortError is caught gracefully', () => {
+  // The .catch() handler should handle AbortError
+  const catchIdx = providerSource.indexOf("err.name === 'AbortError'");
+  assert(catchIdx !== -1, 'should catch AbortError from fetch()');
+  const catchSection = providerSource.substring(catchIdx - 50, catchIdx + 300);
+  assert(catchSection.indexOf("finish_reason: 'aborted'") !== -1,
+    'catch handler should return aborted result instead of throwing');
+});
+
+runTest('provider: processStreamingResponse passes signal to fetch result handler', () => {
+  // Verify the call to processStreamingResponse includes the signal
+  const callPattern = /processStreamingResponse\s*\(\s*response\s*,\s*opts\.onTextChunk\s*,\s*opts\.signal\s*\)/;
+  assert(callPattern.test(providerSource),
+    'processStreamingResponse call should pass opts.signal as third argument');
+});
+
+// ============================================================
+// Functional tests with mock AbortController
+// ============================================================
+
+runTest('functional: AbortController signal.aborted starts false', () => {
+  // Verify AbortController works in this environment
+  if (typeof AbortController === 'undefined') {
+    console.log('  (AbortController not available, skipping)');
+    return;
+  }
+  const ac = new AbortController();
+  assert(ac.signal.aborted === false, 'signal should start not aborted');
+  ac.abort();
+  assert(ac.signal.aborted === true, 'signal should be aborted after abort()');
+});
+
+runTest('functional: abort event fires on AbortController.abort()', () => {
+  if (typeof AbortController === 'undefined') {
+    console.log('  (AbortController not available, skipping)');
+    return;
+  }
+  const ac = new AbortController();
+  let fired = false;
+  ac.signal.addEventListener('abort', () => { fired = true; });
+  ac.abort();
+  assert(fired === true, 'abort event should fire synchronously');
+});
+
+// ============================================================
+// Copilot review round 1: resource cleanup tests
+// ============================================================
+
+runTest('provider: early-abort path destroys response body stream', () => {
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  assert(fnIdx !== -1, 'should find processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 2000);
+  // Find the early abort section (signal && signal.aborted)
+  const earlyAbortIdx = fnSection.indexOf('signal && signal.aborted');
+  assert(earlyAbortIdx !== -1, 'should find early abort check');
+  const earlyAbortSection = fnSection.substring(earlyAbortIdx, earlyAbortIdx + 300);
+  // Must destroy reader before resolving to release HTTP connection
+  assert(earlyAbortSection.indexOf('reader.destroy()') !== -1,
+    'early-abort path should destroy response body stream to release socket');
+});
+
+runTest('provider: onAbort handler cleans up signal listener before resolving', () => {
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 3000);
+  const onAbortIdx = fnSection.indexOf('onAbort = function ()');
+  assert(onAbortIdx !== -1, 'should find onAbort handler');
+  const onAbortSection = fnSection.substring(onAbortIdx, onAbortIdx + 400);
+  // cleanupSignalListener must be called inside onAbort, before resolve
+  assert(onAbortSection.indexOf('cleanupSignalListener()') !== -1,
+    'onAbort handler should call cleanupSignalListener() to prevent leak');
+  // Verify cleanup happens before resolve
+  const cleanupIdx = onAbortSection.indexOf('cleanupSignalListener()');
+  const resolveIdx = onAbortSection.indexOf('resolve(');
+  assert(cleanupIdx < resolveIdx,
+    'cleanupSignalListener should be called before resolve in onAbort');
+});
+
+runTest('provider: close event also cleans up signal listener', () => {
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 12000);
+  // reader.destroy() emits 'close' not 'end', so we need a close handler
+  assert(fnSection.indexOf("reader.on('close'") !== -1,
+    'should listen for close event on reader');
+  // The close handler should call cleanupSignalListener
+  const closeIdx = fnSection.indexOf("reader.on('close'");
+  const closeSection = fnSection.substring(closeIdx, closeIdx + 200);
+  assert(closeSection.indexOf('cleanupSignalListener()') !== -1,
+    'close event handler should clean up signal listener');
+});
+
+// ============================================================
+// Integration: verify signal flow from handler to provider
+// ============================================================
+
+runTest('integration: handler.js signal flows to streamResponse then to fetch', () => {
+  // Trace the signal through the call chain:
+  // 1. handler.js: signal -> streamResponse({...signal})
+  // 2. provider/index.js: streamResponse -> streamGitHubCopilotResponse(opts) -> streamGitHubCopilotResponseInternal(opts)
+  // 3. streamGitHubCopilotResponseInternal: opts.signal -> fetch({signal}) AND processStreamingResponse(response, cb, signal)
+
+  // Check streamResponse passes opts through to provider
+  const streamResponseIdx = providerSource.indexOf('function streamResponse(opts)');
+  assert(streamResponseIdx !== -1, 'should find streamResponse function');
+  const streamResponseSection = providerSource.substring(streamResponseIdx, streamResponseIdx + 300);
+  // streamResponse calls streamGitHubCopilotResponse(opts) which calls streamGitHubCopilotResponseInternal(opts)
+  // so signal in opts is preserved through the chain
+  assert(streamResponseSection.indexOf('streamGitHubCopilotResponse(opts)') !== -1,
+    'streamResponse should pass full opts to provider function');
+});
+
+// ============================================================
+// Copilot review round 2: definition order + runtime tests
+// ============================================================
+
+runTest('provider: cleanupSignalListener defined before onAbort references it', () => {
+  const fnIdx = providerSource.indexOf('async function processStreamingResponse');
+  const fnSection = providerSource.substring(fnIdx, fnIdx + 3000);
+  const cleanupDefIdx = fnSection.indexOf('const cleanupSignalListener = function ()');
+  const onAbortDefIdx = fnSection.indexOf('onAbort = function ()');
+  assert(cleanupDefIdx !== -1, 'should find cleanupSignalListener definition');
+  assert(onAbortDefIdx !== -1, 'should find onAbort definition');
+  assert(cleanupDefIdx < onAbortDefIdx,
+    'cleanupSignalListener must be defined before onAbort to avoid calling undefined');
+});
+
+runTest('runtime: AbortController signal + listener lifecycle simulation', () => {
+  if (typeof AbortController === 'undefined') {
+    console.log('  (AbortController not available, skipping)');
+    return;
+  }
+
+  // We need to test processStreamingResponse directly
+  // It's not exported, so we'll test the behavior by requiring the module
+  // and testing through the exported streamResponse, but that requires
+  // full provider setup. Instead, let's create a mock test:
+
+  const Readable = require('stream').Readable;
+  const ac = new AbortController();
+
+  // Create a mock readable stream that emits SSE data
+  const stream = new Readable({
+    read() {}, // no-op, we push manually
+  });
+
+  // Simulate a response object with body
+  const _mockResponse = { body: stream };
+
+  // Track events
+  let destroyed = false; // eslint-disable-line no-unused-vars
+  const originalDestroy = stream.destroy.bind(stream);
+  stream.destroy = function () {
+    destroyed = true;
+    originalDestroy();
+  };
+
+  // Load processStreamingResponse by extracting it from the module
+  // Since it's not exported, we verify the behavior through the source
+  // inspection tests above and test AbortController mechanics here
+
+  // Test: abort fires synchronously and the signal state changes
+  assert(ac.signal.aborted === false, 'signal starts not aborted');
+
+  let listenerCalled = false;
+  let listenerRemoved = false;
+
+  // Simulate what processStreamingResponse does:
+  const onAbort = function () { listenerCalled = true; };
+  const cleanupSignalListener = function () {
+    ac.signal.removeEventListener('abort', onAbort);
+    listenerRemoved = true;
+  };
+  ac.signal.addEventListener('abort', onAbort);
+
+  // Abort should fire listener synchronously
+  ac.abort();
+  assert(listenerCalled === true, 'abort listener should fire');
+  assert(ac.signal.aborted === true, 'signal should be aborted');
+
+  // Cleanup should work
+  cleanupSignalListener();
+  assert(listenerRemoved === true, 'cleanup should work after abort');
+
+  // Verify listener was actually removed (second abort doesn't re-fire)
+  listenerCalled = false;
+  // Can't abort twice, but we can verify removeEventListener was called
+});
+
+runTest('runtime: pre-aborted signal returns immediately', () => {
+  if (typeof AbortController === 'undefined') {
+    console.log('  (AbortController not available, skipping)');
+    return;
+  }
+
+  const ac = new AbortController();
+  ac.abort(); // Pre-abort
+
+  // Simulate the early-abort check from processStreamingResponse
+  let result = null;
+  if (ac.signal.aborted) {
+    result = { content: [], tool_calls: [], finish_reason: 'aborted' };
+  }
+
+  assert(result !== null, 'should produce result immediately');
+  assert(result.finish_reason === 'aborted', 'finish_reason should be aborted');
+  assert(Array.isArray(result.content), 'content should be array');
+  assert(result.content.length === 0, 'content should be empty for pre-aborted');
+});
+
+runTest('runtime: mock stream destroy + abort lifecycle', () => {
+  if (typeof AbortController === 'undefined') {
+    console.log('  (AbortController not available, skipping)');
+    return;
+  }
+
+  const Readable = require('stream').Readable;
+  const ac = new AbortController();
+
+  // Create mock stream
+  const stream = new Readable({ read() {} });
+  let destroyCalled = false;
+  const origDestroy = stream.destroy.bind(stream);
+  stream.destroy = function () { destroyCalled = true; origDestroy(); };
+
+  // Simulate the full abort handler lifecycle
+  let aborted = false;
+  const fullContent = 'partial content here';
+  let resolvedResult = null;
+
+  let onAbort = null;
+  const cleanupSignalListener = function () {
+    ac.signal.removeEventListener('abort', onAbort);
+  };
+
+  onAbort = function () {
+    if (aborted) return;
+    aborted = true;
+    cleanupSignalListener();
+    stream.destroy();
+    resolvedResult = {
+      content: fullContent ? [{ type: 'text', text: fullContent }] : [],
+      tool_calls: [],
+      finish_reason: 'aborted',
+    };
+  };
+  ac.signal.addEventListener('abort', onAbort);
+
+  // Push some data (simulating partial stream)
+  stream.push('data: {"choices":[{"delta":{"content":"hello"}}]}\n\n');
+
+  // Abort mid-stream
+  ac.abort();
+
+  assert(destroyCalled === true, 'stream should be destroyed on abort');
+  assert(aborted === true, 'aborted flag should be set');
+  assert(resolvedResult !== null, 'should have resolved result');
+  assert(resolvedResult.finish_reason === 'aborted', 'finish_reason should be aborted');
+  assert(resolvedResult.content[0].text === 'partial content here',
+    'should preserve partial content accumulated before abort');
+});
+
+// ============================================================
+// Copilot review round 3 tests
+// ============================================================
+
+runTest('handler.js: aborted path persists partial text before breaking', () => {
+  const abortIdx = handlerSource.indexOf("finishReason === \"aborted\"");
+  assert(abortIdx !== -1, 'should find aborted check');
+  const abortSection = handlerSource.substring(abortIdx, abortIdx + 1000);
+  // Should extract text from response.content before breaking
+  assert(abortSection.indexOf('response.content') !== -1,
+    'aborted path should access response.content to extract partial text');
+  assert(abortSection.indexOf('partManager.add') !== -1,
+    'aborted path should persist partial text via partManager.add');
+  // break should come after persisting
+  const addIdx = abortSection.indexOf('partManager.add');
+  const breakIdx = abortSection.indexOf('break', addIdx);
+  assert(addIdx !== -1 && breakIdx !== -1 && addIdx < breakIdx,
+    'partManager.add should happen before break');
+});
+
+runTest('handler.js: aborted path emits message.part.updated event', () => {
+  const abortIdx = handlerSource.indexOf("finishReason === \"aborted\"");
+  assert(abortIdx !== -1, 'should find aborted check');
+  const abortSection = handlerSource.substring(abortIdx, abortIdx + 900);
+  // After partManager.add, the abort path should emit onEvent so SSE clients reconcile
+  assert(abortSection.indexOf('message.part.updated') !== -1,
+    'aborted path should emit message.part.updated event');
+  assert(abortSection.indexOf('onEvent') !== -1,
+    'aborted path should call onEvent to notify SSE clients');
+  // Verify the pattern: partManager.add stores to abortedPart, then emits it
+  assert(abortSection.indexOf('abortedPart') !== -1,
+    'should capture returned part from partManager.add as abortedPart');
+  const partAddIdx = abortSection.indexOf('partManager.add');
+  const eventIdx = abortSection.indexOf('message.part.updated');
+  assert(partAddIdx < eventIdx,
+    'partManager.add should come before onEvent emission');
+});
+
+runTest('provider: log messages use generic AbortSignal wording', () => {
+  // Should NOT contain "Ctrl+U" in log messages  provider layer is UI-agnostic
+  const abortLogIdx = providerSource.indexOf('Stream aborted via AbortSignal');
+  assert(abortLogIdx !== -1, 'should have generic abort log message');
+  const fetchAbortIdx = providerSource.indexOf('Fetch aborted via AbortSignal');
+  assert(fetchAbortIdx !== -1, 'should have generic fetch abort log message');
+  // Verify no Ctrl+U references remain in provider layer
+  const ctrlUCount = (providerSource.match(/Ctrl\+U/g) || []).length;
+  assert(ctrlUCount === 0, 'provider layer should not reference Ctrl+U (found ' + ctrlUCount + ')');
+});
+
+runTest('handler.js: abort comment and log are UI-agnostic', () => {
+  // The abort comment and log should not reference any specific keybinding
+  const ctrlUCount = (handlerSource.match(/Ctrl\+U/g) || []).length;
+  assert(ctrlUCount === 0, 'handler.js should not reference Ctrl+U (found ' + ctrlUCount + ')');
+  // Should use generic wording mentioning AbortSignal or request abort
+  assert(handlerSource.indexOf('via AbortSignal/request abort') !== -1,
+    'abort comment should mention AbortSignal/request abort');
+  assert(handlerSource.indexOf('aborted via request abort') !== -1,
+    'abort log should use generic request abort wording');
+});
+
+// ============================================================
+// Summary
+// ============================================================
+
+console.log('\nTotal: ' + (passed + failed) + ', Passed: ' + passed + ', Failed: ' + failed);
+if (failed > 0) process.exitCode = 1;