wip ReadableStream for HTTP(s) Server

3 files changed, 217 insertions, 64 deletions

diff --git a/test/bun.js/bigint.test.js b/test/bun.js/bigint.test.js
new file mode 100644
index 000000000..ba71f3f9f
--- /dev/null
+++ b/test/bun.js/bigint.test.js
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "bun:test";
+
+it("BigInt compares correctly (literal)", () => {
+  expect(42n).toBe(42n);
+});
+
+it("BigInt compares correctly (object)", () => {
+  expect(BigInt(42n)).toBe(BigInt(42n));
+  expect(42n).toBe(BigInt(42n));
+  expect(BigInt(Bun.inspect(42n).substring(0, 2))).toBe(BigInt(42n));
+  expect(BigInt(42n).valueOf()).toBe(BigInt(42n));
+});
diff --git a/test/bun.js/serve.test.ts b/test/bun.js/serve.test.ts
index 8b785dd25..eddec6411 100644
--- a/test/bun.js/serve.test.ts
+++ b/test/bun.js/serve.test.ts
@@ -1,82 +1,208 @@
 import { file, serve } from "bun";
-import { expect, it } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { readFileSync } from "fs";
 import { resolve } from "path";
 
 var port = 40000;
 
-it("should work for a hello world", async () => {
-  const server = serve({
-    port: port++,
-    fetch(req) {
-      return new Response(`Hello, world!`);
-    },
-  });
-  const response = await fetch(`http://localhost:${server.port}`);
-  expect(await response.text()).toBe("Hello, world!");
-  server.stop();
-});
+describe("streaming", () => {
+  it("text from JS, one chunk", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
 
-it("should work for a file", async () => {
-  const fixture = resolve(import.meta.dir, "./fetch.js.txt");
-  const textToExpect = readFileSync(fixture, "utf-8");
-
-  const server = serve({
-    port: port++,
-    fetch(req) {
-      return new Response(file(fixture));
-    },
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue(textToExpect);
+              controller.close();
+            },
+          })
+        );
+      },
+    });
+    console.log("fetching");
+    const response = await fetch(`http://localhost:${server.port}`);
+    console.log("finished");
+    const text = await response.text();
+    console.log(text, textToExpect, text === textToExpect);
+    expect(text).toBe(textToExpect);
+    console.log("done");
+    server.stop();
   });
-  const response = await fetch(`http://localhost:${server.port}`);
-  expect(await response.text()).toBe(textToExpect);
-  server.stop();
-});
+  it("text from JS, two chunks", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
 
-it("fetch should work with headers", async () => {
-  const fixture = resolve(import.meta.dir, "./fetch.js.txt");
-
-  const server = serve({
-    port: port++,
-    fetch(req) {
-      if (req.headers.get("X-Foo") !== "bar") {
-        return new Response("X-Foo header not set", { status: 500 });
-      }
-      return new Response(file(fixture), {
-        headers: { "X-Both-Ways": "1" },
-      });
-    },
-  });
-  const response = await fetch(`http://localhost:${server.port}`, {
-    headers: {
-      "X-Foo": "bar",
-    },
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              controller.enqueue(textToExpect.substring(100));
+              controller.close();
+            },
+          })
+        );
+      },
+    });
+    const response = await fetch(`http://localhost:${server.port}`);
+    expect(await response.text()).toBe(textToExpect);
+    server.stop();
   });
 
-  expect(response.status).toBe(200);
-  expect(response.headers.get("X-Both-Ways")).toBe("1");
-  server.stop();
-});
+  it("text from JS, 2 chunks, with delay", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
 
-var count = 200;
-it(`should work for a file ${count} times`, async () => {
-  const fixture = resolve(import.meta.dir, "./fetch.js.txt");
-  const textToExpect = readFileSync(fixture, "utf-8");
-  var ran = 0;
-  const server = serve({
-    port: port++,
-    async fetch(req) {
-      return new Response(file(fixture));
-    },
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              queueMicrotask(() => {
+                controller.enqueue(textToExpect.substring(100));
+                controller.close();
+              });
+            },
+          })
+        );
+      },
+    });
+    const response = await fetch(`http://localhost:${server.port}`);
+    expect(await response.text()).toBe(textToExpect);
+    server.stop();
   });
 
-  // this gets stuck if run about 200 times awaiting all the promises
-  // when the promises are run altogether, instead of one at a time
-  // it's hard to say if this only happens here due to some weird stuff with the test runner
-  // or if it's "real" issue
-  for (let i = 0; i < count; i++) {
+  it("text from JS, 2 chunks, with delay in pull", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
+
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            pull(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              queueMicrotask(() => {
+                controller.enqueue(textToExpect.substring(100));
+                controller.close();
+              });
+            },
+          })
+        );
+      },
+    });
     const response = await fetch(`http://localhost:${server.port}`);
     expect(await response.text()).toBe(textToExpect);
-  }
+    server.stop();
+  });
 
-  server.stop();
+  it("text from JS, 2 chunks, with async pull", async () => {
+    const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+    const textToExpect = readFileSync(fixture, "utf-8");
+
+    const server = serve({
+      port: port++,
+      fetch(req) {
+        return new Response(
+          new ReadableStream({
+            async pull(controller) {
+              controller.enqueue(textToExpect.substring(0, 100));
+              await Promise.resolve();
+              controller.enqueue(textToExpect.substring(100));
+              await Promise.resolve();
+              controller.close();
+            },
+          })
+        );
+      },
+    });
+    const response = await fetch(`http://localhost:${server.port}`);
+    expect(await response.text()).toBe(textToExpect);
+    server.stop();
+  });
 });
+
+// it("should work for a hello world", async () => {
+//   const server = serve({
+//     port: port++,
+//     fetch(req) {
+//       return new Response(`Hello, world!`);
+//     },
+//   });
+//   const response = await fetch(`http://localhost:${server.port}`);
+//   expect(await response.text()).toBe("Hello, world!");
+//   server.stop();
+// });
+
+// it("should work for a file", async () => {
+//   const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+//   const textToExpect = readFileSync(fixture, "utf-8");
+
+//   const server = serve({
+//     port: port++,
+//     fetch(req) {
+//       return new Response(file(fixture));
+//     },
+//   });
+//   const response = await fetch(`http://localhost:${server.port}`);
+//   expect(await response.text()).toBe(textToExpect);
+//   server.stop();
+// });
+
+// it("fetch should work with headers", async () => {
+//   const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+
+//   const server = serve({
+//     port: port++,
+//     fetch(req) {
+//       if (req.headers.get("X-Foo") !== "bar") {
+//         return new Response("X-Foo header not set", { status: 500 });
+//       }
+//       return new Response(file(fixture), {
+//         headers: { "X-Both-Ways": "1" },
+//       });
+//     },
+//   });
+//   const response = await fetch(`http://localhost:${server.port}`, {
+//     headers: {
+//       "X-Foo": "bar",
+//     },
+//   });
+
+//   expect(response.status).toBe(200);
+//   expect(response.headers.get("X-Both-Ways")).toBe("1");
+//   server.stop();
+// });
+
+// var count = 200;
+// it(`should work for a file ${count} times`, async () => {
+//   const fixture = resolve(import.meta.dir, "./fetch.js.txt");
+//   const textToExpect = readFileSync(fixture, "utf-8");
+//   var ran = 0;
+//   const server = serve({
+//     port: port++,
+//     async fetch(req) {
+//       return new Response(file(fixture));
+//     },
+//   });
+
+//   // this gets stuck if run about 200 times awaiting all the promises
+//   // when the promises are run altogether, instead of one at a time
+//   // it's hard to say if this only happens here due to some weird stuff with the test runner
+//   // or if it's "real" issue
+//   for (let i = 0; i < count; i++) {
+//     const response = await fetch(`http://localhost:${server.port}`);
+//     expect(await response.text()).toBe(textToExpect);
+//   }
+
+//   server.stop();
+// });
diff --git a/test/bun.js/streams.test.js b/test/bun.js/streams.test.js
index ccbea1d09..4e869aeaa 100644
--- a/test/bun.js/streams.test.js
+++ b/test/bun.js/streams.test.js
@@ -22,6 +22,21 @@ it("exists globally", () => {
   expect(typeof CountQueuingStrategy).toBe("function");
 });
 
+it("ReadableStream (readMany)", async () => {
+  var stream = new ReadableStream({
+    pull(controller) {
+      controller.enqueue("hello");
+      controller.enqueue("world");
+      controller.close();
+    },
+    cancel() {},
+  });
+  var reader = stream.getReader();
+  const chunk = await reader.readMany();
+  expect(chunk.value.join("")).toBe("helloworld");
+  expect((await reader.read()).done).toBe(true);
+});
+
 it("ReadableStream (direct)", async () => {
   var stream = new ReadableStream({
     pull(controller) {