[Init] Initial commit - NetMesh terminal manager

electron/plugins/pluginStreamEndpoint.test.cjs

@@ -0,0 +1,104 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+async function createPair() {
+  const { createPluginStreamEndpoint } = await import("./runtime/pluginStreamEndpoint.mjs");
+  let left;
+  let right;
+  const leftTransport = {
+    post(message) { queueMicrotask(() => right.accept(message)); },
+  };
+  const rightTransport = {
+    post(message) { queueMicrotask(() => left.accept(message)); },
+  };
+  left = createPluginStreamEndpoint(leftTransport);
+  right = createPluginStreamEndpoint(rightTransport);
+  return { left, right };
+}
+
+test("runtime byte streams transfer owned chunks and end normally", async () => {
+  const { left, right } = await createPair();
+  const readablePromise = right.acceptReadable("connection:output");
+  const writable = await left.openWritable("connection:output", 1024);
+  const readable = await readablePromise;
+
+  await writable.write(Uint8Array.from([1, 2, 3]));
+  assert.deepEqual([...await readable.read()], [1, 2, 3]);
+  const ended = writable.end();
+  assert.equal(await readable.read(), null);
+  await ended;
+});
+
+test("runtime byte streams retain receive credit until the next read", async () => {
+  const { left, right } = await createPair();
+  const readablePromise = right.acceptReadable("import:records");
+  const writable = await left.openWritable("import:records", 1024);
+  const readable = await readablePromise;
+  const first = new Uint8Array(1024);
+  await writable.write(first);
+  assert.equal((await readable.read()).byteLength, 1024);
+
+  let secondSettled = false;
+  const second = writable.write(Uint8Array.of(9)).then(() => { secondSettled = true; });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(secondSettled, false);
+  assert.deepEqual([...await readable.read()], [9]);
+  await second;
+});
+
+test("runtime byte stream cancellation rejects queued writes", async () => {
+  const { left, right } = await createPair();
+  const readablePromise = right.acceptReadable("connection:input");
+  const writable = await left.openWritable("connection:input", 1024);
+  const readable = await readablePromise;
+  await writable.write(new Uint8Array(1024));
+  const blocked = writable.write(Uint8Array.of(1));
+  readable.cancel();
+  await assert.rejects(blocked, /cancel/i);
+});
+
+test("runtime byte streams reject invalid identifiers and windows", async () => {
+  const { left } = await createPair();
+  await assert.rejects(left.openWritable("", 1024), /stream ID/i);
+  await assert.rejects(left.openWritable("valid", 1), /window/i);
+});
+
+test("runtime byte stream end waits behind backpressure and preserves ordering", async () => {
+  const { left, right } = await createPair();
+  const readablePromise = right.acceptReadable("ordered-end");
+  const writable = await left.openWritable("ordered-end", 1024);
+  const readable = await readablePromise;
+  await writable.write(new Uint8Array(1024));
+  const blocked = writable.write(Uint8Array.of(7));
+  const ending = writable.end();
+  assert.equal((await readable.read()).byteLength, 1024);
+  assert.deepEqual([...await readable.read()], [7]);
+  await blocked;
+  assert.equal(await readable.read(), null);
+  await ending;
+});
+
+test("runtime byte streams reject concurrent reads and bound pending accept reservations", async () => {
+  const { left, right } = await createPair();
+  const readablePromise = right.acceptReadable("serial-read");
+  await left.openWritable("serial-read", 1024);
+  const readable = await readablePromise;
+  const pendingRead = readable.read();
+  await assert.rejects(readable.read(), /concurrent reads/i);
+  readable.cancel();
+  await assert.rejects(pendingRead, /cancel/i);
+
+  const firstRead = left.acceptReadable("read-once");
+  await assert.rejects(left.acceptReadable("read-once"), /cannot be accepted/i);
+  left.rejectReadable("read-once");
+  await assert.rejects(firstRead, /cancel/i);
+
+  const { createPluginStreamEndpoint } = await import("./runtime/pluginStreamEndpoint.mjs");
+  const endpoint = createPluginStreamEndpoint({ post() {} }, { maxStreams: 1 });
+  const reserved = endpoint.acceptReadable("reserved");
+  await assert.rejects(endpoint.acceptReadable("overflow"), /limit/i);
+  endpoint.rejectReadable("reserved");
+  await assert.rejects(reserved, /cancel/i);
+});