char-slop/berry

multipurpose self-modifiable agentic harness

git clone https://git.t4t.associates/char-slop/berry

Charlotte Somweb: polyfill stream async iteration for Safarica9626a

main
branchesmainall refs →
2.4 KiB64 linesraw
1import { assertEquals, assertRejects } from "@std/assert";
2
3Deno.test("streams can be iterated without native async-iterator support", async (t) => {
4  const native = Object.getOwnPropertyDescriptor(ReadableStream.prototype, Symbol.asyncIterator)!;
5  Reflect.deleteProperty(ReadableStream.prototype, Symbol.asyncIterator);
6  try {
7    await import("./stream-iterator.ts");
8
9    await t.step("completion releases the reader without canceling", async () => {
10      let canceled = false;
11      const stream = new ReadableStream({
12        start(controller) {
13          controller.enqueue("shell output");
14          controller.close();
15        },
16        cancel: () => void (canceled = true),
17      });
18      const received = [];
19      for await (const chunk of stream) received.push(chunk);
20      assertEquals(received, ["shell output"]);
21      assertEquals(stream.locked, false);
22      assertEquals(canceled, false);
23    });
24
25    await t.step("early exit cancels and releases the reader", async () => {
26      let canceled = false;
27      const stream = new ReadableStream({
28        start: (controller) => controller.enqueue("shell output"),
29        cancel: () => void (canceled = true),
30      });
31      for await (const _ of stream) break;
32      assertEquals(canceled, true);
33      assertEquals(stream.locked, false);
34    });
35
36    await t.step("preventCancel leaves the stream available after early exit", async () => {
37      let canceled = false;
38      const stream = new ReadableStream({
39        start(controller) {
40          controller.enqueue("first");
41          controller.enqueue("second");
42        },
43        cancel: () => void (canceled = true),
44      });
45      for await (const _ of stream[Symbol.asyncIterator]({ preventCancel: true })) break;
46      assertEquals(canceled, false);
47      assertEquals(stream.locked, false);
48      const reader = stream.getReader();
49      assertEquals((await reader.read()).value, "second");
50      await reader.cancel();
51      reader.releaseLock();
52    });
53
54    await t.step("read errors propagate and release the reader", async () => {
55      const stream = new ReadableStream({
56        start: (controller) => controller.error(new Error("connection lost")),
57      });
58      await assertRejects(() => stream[Symbol.asyncIterator]().next(), Error, "connection lost");
59      assertEquals(stream.locked, false);
60    });
61  } finally {
62    Object.defineProperty(ReadableStream.prototype, Symbol.asyncIterator, native);
63  }
64});