refactor(lib/testing): MockWebSocket.instances now returns AsyncGenerator

Author: hasundue

lib/testing.ts

@@ -1,24 +1,40 @@
 type MessageEventData = string | ArrayBufferLike | Blob | ArrayBufferView;
 
 export class MockWebSocket extends EventTarget implements WebSocket {
-  /**
-   * A list of all instances of MockWebSocket.
-   * An instance is removed from this list when it is closed.
-   */
-  static readonly instances = new Set<MockWebSocket>();
+  /** An AsyncGenerator that yields WebSocket instances. */
+  static async *instances() {
+    for (;;) {
+      if (this.#instances.length > 0) {
+        yield this.#instances.shift()!;
+      }
+      await new Promise<void>((resolve) => {
+        this.#pushed = resolve;
+      });
+      this.#pushed = undefined;
+    }
+  }
+  static readonly #instances: MockWebSocket[] = [];
+  static #pushed: (() => void) | undefined;
 
-  constructor(url?: string | URL, protocols?: string | string[]) {
+  constructor(
+    url?: string | URL,
+    protocols?: string | string[],
+    isRemote = false,
+  ) {
     super();
     this.url = url?.toString() ?? "";
     this.protocol = protocols ? [...protocols].flat()[0] : "";
-    MockWebSocket.instances.add(this);
     // Simulate async behavior of WebSocket as much as possible.
     queueMicrotask(() => {
       this.#readyState = 1;
       const ev = new Event("open");
       this.dispatchEvent(ev);
       this.onopen?.(ev);
     });
+    if (!isRemote) {
+      MockWebSocket.#instances.push(this);
+      MockWebSocket.#pushed?.();
+    }
   }
 
   binaryType: "blob" | "arraybuffer" = "blob";
@@ -39,7 +55,7 @@ export class MockWebSocket extends EventTarget implements WebSocket {
 
   get remote(): MockWebSocket {
     if (!this.#remote) {
-      this.#remote = new MockWebSocket(this.url);
+      this.#remote = new MockWebSocket(import.meta.url, undefined, true);
       this.#remote.#remote = this;
     }
     return this.#remote;
@@ -48,20 +64,20 @@ export class MockWebSocket extends EventTarget implements WebSocket {
 
   close(code?: number, reason?: string): void {
     this.#readyState = 2;
+    if (this.#remote) {
+      this.#remote.#readyState = 2;
+    }
     // Simulate async behavior of WebSocket as much as possible.
     queueMicrotask(() => {
+      const ev = new CloseEvent("close", { code, reason });
       if (this.#remote) {
         this.#remote.#readyState = 3;
-        const ev = new CloseEvent("close", { code, reason });
         this.#remote.dispatchEvent(ev);
         this.#remote.onclose?.(ev);
-        MockWebSocket.instances.delete(this.#remote);
       }
       this.#readyState = 3;
-      const ev = new CloseEvent("close", { code, reason });
       this.dispatchEvent(ev);
       this.onclose?.(ev);
-      MockWebSocket.instances.delete(this);
     });
   }
 

lib/testing_test.ts

@@ -1,5 +1,5 @@
 import { beforeAll, describe, it } from "@std/testing/bdd";
-import { assert, assertEquals } from "@std/assert";
+import { assert, assertEquals, assertInstanceOf } from "@std/assert";
 import { MockWebSocket } from "@lophus/lib/testing";
 
 describe("MockWebSocket", () => {
@@ -21,8 +21,36 @@ describe("MockWebSocket", () => {
   });
 
   describe("instances", () => {
-    it("should return a set of instances", () => {
-      assertEquals(MockWebSocket.instances.size, 2);
+    it("should return an AsyncGenerator of WebSocket instances", () => {
+      assertEquals(typeof MockWebSocket.instances().next, "function");
+    });
+
+    describe("next", () => {
+      let third: Promise<IteratorResult<MockWebSocket>>;
+
+      it("should return the first instance", async () => {
+        const { value, done } = await MockWebSocket.instances().next();
+        assert(!done);
+        assertEquals(value.url, "");
+      });
+
+      it("should return the second instance", async () => {
+        const { value, done } = await MockWebSocket.instances().next();
+        assert(!done);
+        assertEquals(value.url, "wss://localhost:8080");
+      });
+
+      it("should return a promise for the next instance", () => {
+        third = MockWebSocket.instances().next();
+        assertInstanceOf(third, Promise);
+      });
+
+      it("should return the third instance when created", async () => {
+        new MockWebSocket("wss://localhost:8081");
+        const { value, done } = await third;
+        assert(!done);
+        assertEquals(value.url, "wss://localhost:8081");
+      });
     });
   });
 
@@ -35,27 +63,27 @@ describe("MockWebSocket", () => {
   describe("remote", () => {
     it("should return a remote instance", () => {
       assert(ws.remote);
-      assertEquals(ws.remote.url, ws.url);
+      assert(ws.remote.url.startsWith("file:"));
       assertEquals(ws.remote.remote, ws);
     });
   });
 
   describe("send", () => {
     it("should send a message to the remote WebSocket", async () => {
-      const promise = new Promise<true>((resolve) => {
-        ws.remote.addEventListener("message", () => resolve(true));
+      const promise = new Promise((resolve) => {
+        ws.remote.addEventListener("message", resolve);
       });
       ws.send("test");
       assert(await promise);
     });
   });
 
   describe("close", () => {
-    let remote_closed: Promise<true>;
+    let remote_closed: Promise<unknown>;
 
     beforeAll(() => {
-      remote_closed = new Promise<true>((resolve) => {
-        ws.remote.addEventListener("close", () => resolve(true));
+      remote_closed = new Promise((resolve) => {
+        ws.remote.addEventListener("close", resolve);
       });
     });
 
@@ -64,16 +92,14 @@ describe("MockWebSocket", () => {
         ws.addEventListener("close", () => resolve(true));
       });
       ws.close();
-      assert(await closed);
+      assertEquals(ws.readyState, WebSocket.CLOSING);
+      await closed;
       assertEquals(ws.readyState, WebSocket.CLOSED);
     });
 
-    it("should close the remote WebSocket", () => {
-      assertEquals(ws.remote.readyState, WebSocket.CLOSED);
-    });
-
-    it("should trigger the onclose event on the remote WebSocket", async () => {
-      assert(await remote_closed);
+    it("should close the remote WebSocket", async () => {
+      await remote_closed;
+      assert(ws.remote.readyState === WebSocket.CLOSED);
     });
   });
 });

lib/websockets_test.ts

@@ -28,7 +28,7 @@ describe("LazyWebSocket", () => {
 
   it("should not open a WebSocket when an event listener is added", () => {
     opened = new Promise((resolve) => {
-      lazy.addEventListener("open", () => resolve(true));
+      lazy.addEventListener("open", () => resolve(true), { once: true });
     });
     assertEquals(lazy.readyState, WebSocket.CLOSED);
   });
@@ -46,14 +46,15 @@ describe("LazyWebSocket", () => {
     const errored = new Promise((resolve) => {
       lazy.addEventListener("error", resolve);
     });
-    socket = MockWebSocket.instances.values().next().value;
+    const { value } = await MockWebSocket.instances().next();
+    socket = value!;
     socket.dispatchEvent(new Event("error"));
     await errored;
   });
 
   it("should trigger the onmessage event when receives a message", async () => {
     const messaged = new Promise((resolve) => {
-      lazy.addEventListener("message", resolve);
+      lazy.addEventListener("message", resolve, { once: true });
     });
     server = socket.remote;
     server.send("test");
@@ -63,12 +64,21 @@ describe("LazyWebSocket", () => {
   it("should trigger the onclose event when the WebSocket is closed", async () => {
     await lazy.ready();
     const closed = new Promise((resolve) => {
-      lazy.addEventListener("close", resolve);
+      lazy.addEventListener("close", resolve, { once: true });
     });
     server.close();
     await closed;
   });
 
+  it("should reregister the event listeners when the WebSocket is recreated", async () => {
+    const closed = new Promise((resolve) => {
+      lazy.addEventListener("close", resolve, { once: true });
+    });
+    await lazy.ready();
+    server.close();
+    await closed;
+  });
+
   it("should close the WebSocket when the LazyWebSocket is closed", async () => {
     await lazy.close();
     assertEquals(lazy.readyState, WebSocket.CLOSED);

nips/01/relays_test.ts

@@ -15,13 +15,15 @@ import {
 } from "@lophus/core/relays";
 import { Relay } from "../relays.ts";
 
-function getRemoteSocket() {
-  return MockWebSocket.instances.values().next().value.remote;
+async function getRemoteSocket() {
+  const { value } = await MockWebSocket.instances().next();
+  return value!.remote;
 }
 
 describe("Relay (NIP-01)", () => {
   const url = "wss://localhost:8080";
   let relay: Relay;
+  let remote: MockWebSocket;
   let sub_0: ReadableStream<NostrEvent<0>>;
   let sub_1: ReadableStream<NostrEvent<1>>;
 
@@ -47,9 +49,9 @@ describe("Relay (NIP-01)", () => {
 
   it("should receive text notes", async () => {
     const reader = sub_1.getReader();
-    const read = reader.read();
-    getRemoteSocket().send(JSON.stringify(["EVENT", "test-1", { kind: 1 }]));
-    const { value, done } = await read;
+    remote = await getRemoteSocket();
+    remote.send(JSON.stringify(["EVENT", "test-1", { kind: 1 }]));
+    const { value, done } = await reader.read();
     assert(!done);
     assertEquals(value.kind, 1);
     reader.releaseLock();
@@ -63,7 +65,6 @@ describe("Relay (NIP-01)", () => {
   it("should recieve metas and notes simultaneously", async () => {
     const reader_0 = sub_0.getReader();
     const reader_1 = sub_1.getReader();
-    const remote = getRemoteSocket();
     remote.send(JSON.stringify(["EVENT", "test-0", { kind: 0 }]));
     remote.send(JSON.stringify(["EVENT", "test-1", { kind: 1 }]));
     const [{ value: value_0 }, { value: value_1 }] = await Promise.all([
@@ -79,7 +80,7 @@ describe("Relay (NIP-01)", () => {
   });
 
   it("should close a subscription with an error when receiving a CLOSED message", async () => {
-    getRemoteSocket().send(JSON.stringify(
+    remote.send(JSON.stringify(
       [
         "CLOSED",
         "test-1" as SubscriptionId,
@@ -99,14 +100,15 @@ describe("Relay (NIP-01)", () => {
 
   it("should reconnect if connection is closed while waiting for an event", async () => {
     const reader = sub_0.getReader();
-    const read = reader.read();
-    getRemoteSocket().close();
+    const read = reader.read(); // wait for an event
+    remote.close();
     const reconnected = new Promise<true>((resolve) => {
       relay.ws.addEventListener("open", () => resolve(true));
     });
     assert(await reconnected);
     // We must use a new instance of MockWebSocket.
-    getRemoteSocket().send(JSON.stringify(["EVENT", "test-0", { kind: 0 }]));
+    remote = await getRemoteSocket();
+    remote.send(JSON.stringify(["EVENT", "test-0", { kind: 0 }]));
     const { value, done } = await read;
     assert(!done);
     assertEquals(value.kind, 0);
@@ -115,7 +117,6 @@ describe("Relay (NIP-01)", () => {
 
   it("should publish an event and recieve an accepting OK message", async () => {
     const eid = "test-true" as EventId;
-    const remote = getRemoteSocket();
     const arrived = new Promise<true>((resolve) => {
       remote.addEventListener(
         "message",
@@ -143,7 +144,6 @@ describe("Relay (NIP-01)", () => {
     const eid = "test-false" as EventId;
     // deno-fmt-ignore
     const msg = ["OK", eid, false, "error: test"] satisfies RelayToClientMessage<"OK">
-    const remote = getRemoteSocket();
     const arrived = new Promise<true>((resolve) => {
       remote.addEventListener(
         "message",
@@ -174,7 +174,7 @@ describe("Relay (NIP-01)", () => {
     const event = { id: "test-close" as EventId, kind: 1 };
     // deno-lint-ignore no-explicit-any
     const published = relay.publish(event as any).catch((e) => e);
-    getRemoteSocket().close();
+    remote.close();
     try {
       await published;
     } catch (e) {