fix(search): harden response abort handling

Coverage: 94.90% (was 94.94%)

Author: ihor-sokoliuk

__tests__/unit/instance-info.test.ts

@@ -716,31 +716,44 @@ async function runTests() {
     const mockServer = createMockServer();
     const timeoutDescriptor = Object.getOwnPropertyDescriptor(AbortSignal, 'timeout');
     let observedSignal: AbortSignal | undefined;
+    let attempts = 0;
+    const timeoutReason = new Error('bounded test timeout');
+    const cancellationReasons: unknown[] = [];
+    let responseBody: ReadableStream<Uint8Array> | undefined;
     fetchMocker.mock(async (_url, options) => {
+      attempts++;
       observedSignal = options?.signal ?? undefined;
-      let controller: ReadableStreamDefaultController<Uint8Array> | undefined;
-      const response = new Response(new ReadableStream<Uint8Array>({
-        start(streamController) {
-          controller = streamController;
+      responseBody = new ReadableStream<Uint8Array>({
+        cancel(reason) {
+          cancellationReasons.push(reason);
         },
-      }), { status: 200 });
-      observedSignal?.addEventListener('abort', () => controller?.error(observedSignal?.reason), { once: true });
-      return response;
+      });
+      return new Response(responseBody, { status: 200 });
     });
     Object.defineProperty(AbortSignal, 'timeout', {
       configurable: true,
       value: () => {
         const controller = new AbortController();
-        setTimeout(() => controller.abort(new Error('bounded test timeout')), 5);
+        setTimeout(() => controller.abort(timeoutReason), 5);
         return controller.signal;
       },
     });
 
     try {
-      const payload = JSON.parse(await fetchInstanceInfo(mockServer as any));
+      const payload = JSON.parse(await Promise.race([
+        fetchInstanceInfo(mockServer as any),
+        new Promise<never>((_resolve, reject) => {
+          setTimeout(() => reject(new Error('stalled /config response did not become unavailable promptly')), 250);
+        }),
+      ]));
+      const cachedPayload = JSON.parse(await fetchInstanceInfo(mockServer as any));
       assert.ok(observedSignal, 'expected the /config request signal');
       assert.equal(observedSignal.aborted, true);
       assert.equal(payload.available, false);
+      assert.equal(cachedPayload.available, false);
+      assert.equal(attempts, 1, 'a timed-out response must not populate the successful cache');
+      assert.deepEqual(cancellationReasons, [timeoutReason]);
+      assert.equal(responseBody?.locked, false, 'the shared reader must release its body lock after cancellation');
     } finally {
       if (timeoutDescriptor) {
         Object.defineProperty(AbortSignal, 'timeout', timeoutDescriptor);

__tests__/unit/search.test.ts

@@ -3311,6 +3311,56 @@ async function runTests() {
     }
   }, results);
 
+  await testFunction('HTML fallback accepts an exact response-body limit and rejects the next byte without caching or recording success', async () => {
+    searchCache.clear();
+    clearSearxngInstanceStateForTests();
+    envManager.set('SEARXNG_URL', 'https://fallback-bounded.example.com');
+    envManager.set('SEARXNG_HTML_FALLBACK', 'true');
+    const exactBody = searxngHtmlFixture;
+    envManager.set('SEARXNG_MAX_RESPONSE_BYTES', String(Buffer.byteLength(exactBody)));
+    const mockServer = createMockServer();
+    let jsonFetchCount = 0;
+    let htmlFetchCount = 0;
+    fetchMocker.mock(async (url) => {
+      const requestUrl = new URL(url.toString());
+      if (requestUrl.searchParams.get('format') === 'json') {
+        jsonFetchCount++;
+        return new Response('JSON format is disabled', { status: 403, statusText: 'Forbidden' });
+      }
+
+      htmlFetchCount++;
+      return createStreamResponse([utf8(htmlFetchCount === 1 ? exactBody : `${exactBody} `)]);
+    });
+
+    try {
+      const exactResult = await performWebSearch(mockServer as any, 'fallback exact body');
+      assert.ok(exactResult.includes('Alpha Result'));
+
+      envManager.set('SEARXNG_URL', 'https://fallback-bounded.example.com;https://cooled.example.com');
+      recordSearxngInstanceFailure('https://fallback-bounded.example.com');
+      recordSearxngInstanceFailure('https://fallback-bounded.example.com');
+      recordSearxngInstanceFailure('https://cooled.example.com');
+      recordSearxngInstanceFailure('https://cooled.example.com');
+      recordSearxngInstanceFailure('https://cooled.example.com');
+      await assert.rejects(
+        () => performWebSearch(mockServer as any, 'fallback next byte'),
+        /SearXNG response exceeds configured byte limit/,
+      );
+      assert.equal(isSearxngInstanceCooledDown('https://fallback-bounded.example.com'), true);
+
+      clearSearxngInstanceStateForTests();
+      envManager.set('SEARXNG_MAX_RESPONSE_BYTES', String(Buffer.byteLength(exactBody) + 1));
+      await performWebSearch(mockServer as any, 'fallback next byte');
+      assert.equal(htmlFetchCount, 3, 'an oversize HTML fallback response must not be stored in the search cache');
+      assert.equal(jsonFetchCount, 3, 'each HTML fallback attempt must begin with the JSON request');
+    } finally {
+      fetchMocker.restore();
+      envManager.restore();
+      searchCache.clear();
+      clearSearxngInstanceStateForTests();
+    }
+  }, results);
+
   await testFunction('search rejects partial and invalid bounded JSON before cache writes', async () => {
     searchCache.clear();
     clearSearxngInstanceStateForTests();

__tests__/unit/searxng-response.test.ts

@@ -16,37 +16,39 @@ import { createTestResults, exitWithResults, printTestSummary, testFunction } fr
 const results = createTestResults();
 const encoder = new TextEncoder();
 
-function responseWithChunks(chunks: Uint8Array[], options: { cancelRejects?: boolean; readRejects?: boolean } = {}) {
+interface StreamOptions {
+  cancelRejects?: boolean;
+  leaveOpen?: boolean;
+  readRejects?: boolean;
+  pending?: boolean;
+}
+
+function responseWithChunks(chunks: Uint8Array[], options: StreamOptions = {}) {
   let cancelCalls = 0;
-  let releaseCalls = 0;
-  let index = 0;
-  const reader = {
-    async read(): Promise<ReadableStreamReadResult<Uint8Array>> {
+  let cancelReason: unknown;
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
       if (options.readRejects) {
-        throw new Error("read failed");
+        controller.error(new Error("read failed"));
+        return;
       }
-      const value = chunks[index++];
-      return value === undefined ? { done: true, value: undefined } : { done: false, value };
-    },
-    async cancel(): Promise<void> {
-      cancelCalls++;
-      if (options.cancelRejects) {
-        throw new Error("cancel failed");
+      if (!options.pending) {
+        for (const chunk of chunks) controller.enqueue(chunk);
+        if (!options.leaveOpen) controller.close();
       }
     },
-    releaseLock(): void {
-      releaseCalls++;
+    cancel(reason) {
+      cancelCalls++;
+      cancelReason = reason;
+      if (options.cancelRejects) return Promise.reject(new Error("cancel failed"));
+      return undefined;
     },
-  };
+  });
+  const response = new Response(stream);
   return {
-    response: {
-      body: {
-        getReader: () => reader,
-        cancel: () => reader.cancel(),
-      },
-    } as Response,
+    response,
     getCancelCalls: () => cancelCalls,
-    getReleaseCalls: () => releaseCalls,
+    getCancelReason: () => cancelReason,
   };
 }
 
@@ -62,6 +64,16 @@ function createLogger() {
   };
 }
 
+async function expectPromptAbort(promise: Promise<unknown>, reason: Error): Promise<void> {
+  await assert.rejects(
+    Promise.race([
+      promise,
+      new Promise((_, reject) => setTimeout(() => reject(new Error("abort was not prompt")), 50)),
+    ]),
+    (error: unknown) => error === reason,
+  );
+}
+
 async function runTests() {
   console.log("🧪 Testing: searxng-response.ts\n");
 
@@ -71,7 +83,7 @@ async function runTests() {
     assert.equal(PREVIEW_MAX_SEARXNG_RESPONSE_BYTES, 64 * 1024);
   }, results);
 
-  await testFunction("resolves only accepted response-size configuration and warns once without raw values", async () => {
+  await testFunction("pins accepted and rejected response-size configuration forms with value-free once-only warnings", async () => {
     const previous = process.env.SEARXNG_MAX_RESPONSE_BYTES;
     const logger = createLogger();
     resetSearxngResponseConfigWarningsForTesting();
@@ -82,18 +94,21 @@ async function runTests() {
       assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), 1);
       process.env.SEARXNG_MAX_RESPONSE_BYTES = " 16777216 ";
       assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), HARD_MAX_SEARXNG_RESPONSE_BYTES);
+      process.env.SEARXNG_MAX_RESPONSE_BYTES = "+5242880";
+      assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), 5242880);
+      process.env.SEARXNG_MAX_RESPONSE_BYTES = "0005242880";
+      assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), 5242880);
       process.env.SEARXNG_MAX_RESPONSE_BYTES = "  ";
       assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), DEFAULT_SEARXNG_RESPONSE_MAX_BYTES);
-      process.env.SEARXNG_MAX_RESPONSE_BYTES = "0";
-      assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), DEFAULT_SEARXNG_RESPONSE_MAX_BYTES);
-      process.env.SEARXNG_MAX_RESPONSE_BYTES = "16777217";
-      assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), DEFAULT_SEARXNG_RESPONSE_MAX_BYTES);
-      process.env.SEARXNG_MAX_RESPONSE_BYTES = "5.5";
-      assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), DEFAULT_SEARXNG_RESPONSE_MAX_BYTES);
+      for (const invalid of ["0", "16777217", "5.5", "-0", "1e3", "5MB", "9007199254740992"]) {
+        process.env.SEARXNG_MAX_RESPONSE_BYTES = invalid;
+        assert.equal(resolveSearxngResponseMaxBytes(logger.server as any), DEFAULT_SEARXNG_RESPONSE_MAX_BYTES);
+      }
       await Promise.resolve();
       assert.equal(logger.messages.length, 1);
-      assert.ok(!logger.messages[0].includes("16777217"));
+      assert.ok(!logger.messages[0].includes("9007199254740992"));
       resetSearxngResponseConfigWarningsForTesting();
+      process.env.SEARXNG_MAX_RESPONSE_BYTES = "5MB";
       resolveSearxngResponseMaxBytes(logger.server as any);
       await Promise.resolve();
       assert.equal(logger.messages.length, 2);
@@ -104,44 +119,48 @@ async function runTests() {
     }
   }, results);
 
-  await testFunction("complete mode accepts exact bytes, rejects the next byte, and releases its lock", async () => {
+  await testFunction("complete mode accepts exact bytes, rejects the next byte, cancels, and unlocks actual bodies", async () => {
     const exact = responseWithChunks([encoder.encode("abc")]);
     assert.deepEqual(await readSearxngResponseBody(exact.response, 3), {
       text: "abc", bytesRead: 3, truncated: false,
     });
-    assert.equal(exact.getReleaseCalls(), 1);
-    const overflow = responseWithChunks([encoder.encode("abcd")]);
+    assert.equal(exact.response.body!.locked, false);
+    const overflow = responseWithChunks([encoder.encode("abcd")], { leaveOpen: true });
     await assert.rejects(() => readSearxngResponseBody(overflow.response, 3), /SearXNG response exceeds configured byte limit/);
     assert.equal(overflow.getCancelCalls(), 1);
-    assert.equal(overflow.getReleaseCalls(), 1);
-    const overflowWithCancelFailure = responseWithChunks([encoder.encode("abcd")], { cancelRejects: true });
+    assert.equal(overflow.response.body!.locked, false);
+    const overflowWithCancelFailure = responseWithChunks([encoder.encode("abcd")], { cancelRejects: true, leaveOpen: true });
     await assert.rejects(
       () => readSearxngResponseBody(overflowWithCancelFailure.response, 3),
       /SearXNG response exceeds configured byte limit/,
     );
-    assert.equal(overflowWithCancelFailure.getReleaseCalls(), 1);
+    assert.equal(overflowWithCancelFailure.getCancelCalls(), 1);
+    assert.equal(overflowWithCancelFailure.response.body!.locked, false);
   }, results);
 
-  await testFunction("complete mode measures raw UTF-8 bytes before decoding", async () => {
+  await testFunction("complete mode measures raw UTF-8 bytes before decoding with actual bodies", async () => {
     const response = responseWithChunks([new Uint8Array([0xe2]), new Uint8Array([0x82, 0xac])]);
     assert.deepEqual(await readSearxngResponseBody(response.response, 3), {
       text: "€", bytesRead: 3, truncated: false,
     });
+    assert.equal(response.response.body!.locked, false);
     const partial = responseWithChunks([new Uint8Array([0xe2]), new Uint8Array([0x82])]);
     assert.equal((await readSearxngResponseBody(partial.response, 2)).text, "�");
+    assert.equal(partial.response.body!.locked, false);
   }, results);
 
-  await testFunction("preview mode truncates at its effective limit and preserves cancellation result", async () => {
-    const truncated = responseWithChunks([encoder.encode("abcd")]);
+  await testFunction("preview mode truncates at its effective limit, cancels, and unlocks actual bodies", async () => {
+    const truncated = responseWithChunks([encoder.encode("abcd")], { leaveOpen: true });
     assert.deepEqual(await readSearxngResponseBody(truncated.response, 10, { preview: true, previewMaxBytes: 3 }), {
       text: "abc", bytesRead: 4, truncated: true,
     });
     assert.equal(truncated.getCancelCalls(), 1);
-    assert.equal(truncated.getReleaseCalls(), 1);
-    const cancelRejects = responseWithChunks([encoder.encode("abcd")], { cancelRejects: true });
+    assert.equal(truncated.response.body!.locked, false);
+    const cancelRejects = responseWithChunks([encoder.encode("abcd")], { cancelRejects: true, leaveOpen: true });
     const result = await readSearxngResponseBody(cancelRejects.response, 3, { preview: true });
     assert.equal(result.truncated, true);
-    assert.equal(cancelRejects.getReleaseCalls(), 1);
+    assert.equal(cancelRejects.getCancelCalls(), 1);
+    assert.equal(cancelRejects.response.body!.locked, false);
   }, results);
 
   await testFunction("null body is empty while an absent body is rejected without text fallback", async () => {
@@ -152,13 +171,37 @@ async function runTests() {
     await assert.rejects(() => readSearxngResponseBody(invalidResponse, 3), /Invalid SearXNG response body/);
   }, results);
 
-  await testFunction("reader failures release the lock and auxiliary cancellation never surfaces cancellation failures", async () => {
+  await testFunction("reader failures unlock actual bodies and auxiliary cancellation hides cancellation rejection", async () => {
     const rejectedRead = responseWithChunks([], { readRejects: true });
     await assert.rejects(() => readSearxngResponseBody(rejectedRead.response, 3), /read failed/);
-    assert.equal(rejectedRead.getReleaseCalls(), 1);
-    const auxiliary = responseWithChunks([], { cancelRejects: true });
+    assert.equal(rejectedRead.response.body!.locked, false);
+    const auxiliary = responseWithChunks([], { pending: true, cancelRejects: true });
     await cancelAuxiliaryResponseBody(auxiliary.response);
     assert.equal(auxiliary.getCancelCalls(), 1);
+    assert.equal(auxiliary.response.body!.locked, false);
+  }, results);
+
+  await testFunction("signal abort cancels through the reader, unlocks the actual body, and keeps abort stable when cancel rejects", async () => {
+    const controller = new AbortController();
+    const reason = new Error("caller aborted");
+    const pending = responseWithChunks([], { pending: true });
+    const read = readSearxngResponseBody(pending.response, 3, { signal: controller.signal });
+    await Promise.resolve();
+    controller.abort(reason);
+    await expectPromptAbort(read, reason);
+    assert.equal(pending.getCancelCalls(), 1);
+    assert.equal(pending.getCancelReason(), reason);
+    assert.equal(pending.response.body!.locked, false);
+
+    const rejectingController = new AbortController();
+    const rejectingReason = new Error("caller aborted with rejecting cancel");
+    const rejecting = responseWithChunks([], { pending: true, cancelRejects: true });
+    const rejectingRead = readSearxngResponseBody(rejecting.response, 3, { signal: rejectingController.signal });
+    await Promise.resolve();
+    rejectingController.abort(rejectingReason);
+    await expectPromptAbort(rejectingRead, rejectingReason);
+    assert.equal(rejecting.getCancelCalls(), 1);
+    assert.equal(rejecting.response.body!.locked, false);
   }, results);
 
   printTestSummary(results, "SearXNG Response Module");

__tests__/unit/suggestions.test.ts

@@ -155,12 +155,16 @@ async function runTests() {
     }
   }, results);
 
-  await testFunction('keeps the five-second signal active while a headers-first body stalls', async () => {
+  await testFunction('cancels a stalled response body with the five-second request signal', async () => {
     envManager.set('SEARXNG_URL', 'https://test-searx.example.com');
     const mockServer = createMockServer();
     const originalTimeout = AbortSignal.timeout;
     const controller = new AbortController();
+    const abortReason = new Error('autocomplete deadline elapsed');
     let requestedTimeout: number | undefined;
+    let cancelCalls = 0;
+    let cancellationReason: unknown;
+    let responseBody: ReadableStream<Uint8Array> | undefined;
 
     try {
       Object.defineProperty(AbortSignal, 'timeout', {
@@ -171,22 +175,30 @@ async function runTests() {
         },
       });
       fetchMocker.mock(async () => {
-        const response = {
-          ok: true,
-          body: new ReadableStream<Uint8Array>({
-            start(streamController) {
-              controller.signal.addEventListener('abort', () => streamController.error(new Error('aborted while reading body')));
-            },
-          }),
-          json: async () => ['type', ['unbounded-json-result']],
-        } as unknown as Response;
+        const stalledStream = new ReadableStream<Uint8Array>({
+          cancel(reason) {
+            cancelCalls++;
+            cancellationReason = reason;
+          },
+        });
+        const response = new Response(stalledStream, { status: 200 });
+        responseBody = response.body ?? undefined;
         return response;
       });
       const pending = performSearchSuggestions(mockServer as any, 'type');
       await Promise.resolve();
-      controller.abort();
-      assert.deepEqual(await pending, []);
+      controller.abort(abortReason);
+      const result = await Promise.race([
+        pending,
+        new Promise<never>((_resolve, reject) => {
+          setTimeout(() => reject(new Error('autocomplete did not finish after its abort signal')), 100);
+        }),
+      ]);
+      assert.deepEqual(result, []);
       assert.equal(requestedTimeout, 5000);
+      assert.equal(cancelCalls, 1);
+      assert.equal(cancellationReason, abortReason);
+      assert.equal(responseBody?.locked, false);
     } finally {
       Object.defineProperty(AbortSignal, 'timeout', { configurable: true, value: originalTimeout });
       fetchMocker.restore();