Tests

Author: andreiborza

packages/deno/src/utils/streaming.ts

@@ -81,7 +81,10 @@ function monitorStream(
   onDone: () => void,
 ): ReadableStream<Uint8Array<ArrayBufferLike>> {
   const reader = stream.getReader();
-  reader.closed.then(() => onDone(), () => onDone());
+  reader.closed.then(
+    () => onDone(),
+    () => onDone(),
+  );
   return new ReadableStream({
     async start(controller) {
       let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;

packages/deno/test/streaming.test.ts

@@ -2,57 +2,42 @@
 
 import { assertEquals } from 'https://deno.land/std@0.212.0/assert/mod.ts';
 
-/**
- * Minimal reproduction of monitorStream to verify that reader.releaseLock()
- * after stream completion does not cause an unhandled promise rejection.
- *
- * Per the WHATWG Streams spec, releaseLock() rejects reader.closed.
- * Using .then(onDone, onDone) handles both the fulfilled and rejected cases
- * so the rejection is suppressed.
- */
-function monitorStream(
-  stream: ReadableStream<Uint8Array>,
-  onDone: () => void,
-): ReadableStream<Uint8Array> {
-  const reader = stream.getReader();
-  reader.closed.then(() => onDone(), () => onDone());
-  return new ReadableStream({
-    async start(controller) {
-      let result: ReadableStreamReadResult<Uint8Array>;
-      do {
-        result = await reader.read();
-        if (result.value) {
-          try {
-            controller.enqueue(result.value);
-          } catch (er) {
-            controller.error(er);
-            reader.releaseLock();
-            return;
-          }
-        }
-      } while (!result.done);
-      controller.close();
-      reader.releaseLock();
-    },
-  });
-}
+Deno.test('reader.closed.then(f, f) suppresses rejection when releaseLock is called on an open stream', async () => {
+  // Reproduces the bug from GitHub issue #20177:
+  // In monitorStream, reader.releaseLock() is called while the source stream
+  // is still open (e.g. the error path when controller.enqueue() throws).
+  // Per WHATWG Streams spec, this rejects reader.closed with a TypeError.
+  // Using .then(onDone, onDone) handles both cases; .finally() would propagate
+  // the rejection as unhandled.
 
-Deno.test('monitorStream calls onDone and does not cause unhandled rejection after normal completion', async () => {
-  let doneCalled = false;
+  let onDoneCalled = false;
 
-  const source = new ReadableStream<Uint8Array>({
+  const stream = new ReadableStream<Uint8Array>({
     start(controller) {
-      controller.enqueue(new TextEncoder().encode('chunk1'));
-      controller.enqueue(new TextEncoder().encode('chunk2'));
-      controller.close();
+      controller.enqueue(new TextEncoder().encode('data'));
+      // intentionally not closing — stream stays open
     },
   });
 
-  const monitored = monitorStream(source, () => {
-    doneCalled = true;
-  });
+  const reader = stream.getReader();
+
+  // This is the exact pattern from monitorStream (line 84 in streaming.ts).
+  // With .finally(() => onDone()), this would propagate the rejection.
+  reader.closed.then(
+    () => {
+      onDoneCalled = true;
+    },
+    () => {
+      onDoneCalled = true;
+    },
+  );
+
+  await reader.read();
+
+  // This is what monitorStream does on the error path (line 98) when
+  // controller.enqueue() throws — releaseLock while the source is still open.
+  reader.releaseLock();
 
-  // Listen for unhandled rejections — the bug caused one here.
   let unhandledRejection: PromiseRejectionEvent | undefined;
   const handler = (e: PromiseRejectionEvent): void => {
     e.preventDefault();
@@ -61,28 +46,11 @@ Deno.test('monitorStream calls onDone and does not cause unhandled rejection aft
   globalThis.addEventListener('unhandledrejection', handler);
 
   try {
-    const reader = monitored.getReader();
-    const chunks: string[] = [];
-    const decoder = new TextDecoder();
-
-    let result: ReadableStreamReadResult<Uint8Array>;
-    do {
-      result = await reader.read();
-      if (result.value) {
-        chunks.push(decoder.decode(result.value));
-      }
-    } while (!result.done);
-    reader.releaseLock();
-
-    assertEquals(chunks, ['chunk1', 'chunk2']);
-
-    // Give microtasks a chance to settle so any unhandled rejection fires.
     await new Promise(resolve => setTimeout(resolve, 50));
 
-    assertEquals(doneCalled, true, 'onDone callback should have been called');
+    assertEquals(onDoneCalled, true, 'onDone should have been called via the rejection handler');
     assertEquals(unhandledRejection, undefined, 'should not have caused an unhandled promise rejection');
   } finally {
     globalThis.removeEventListener('unhandledrejection', handler);
   }
 });
-