quic-transport: test cases for Node.js

Author: yoursunny

pkg/quic-transport/src/h3-transport.ts

@@ -81,6 +81,12 @@ export namespace H3Transport {
      * @defaultValue 10000
      */
     connectTimeout?: number;
+
+    /**
+     * Skip TLS certificate verification (Node.js only).
+     * @defaultValue false
+     */
+    insecureSkipVerify?: boolean;
   }
 
   /** Create a transport and add to forwarder. */

pkg/quic-transport/src/wt_node.ts

@@ -1,10 +1,14 @@
 import { WebTransport as bunWebTransport } from "@webtransport-bun/webtransport";
 
+import type { H3Transport } from "./h3-transport";
+
 export const supported = true;
 
 export function makeWebTransport(uri: string, opts: WebTransportOptions): WebTransport {
+  const { insecureSkipVerify = false } = opts as H3Transport.Options;
   void opts;
   return new bunWebTransport(uri, {
     strictW3CErrors: true,
+    tls: { insecureSkipVerify },
   }) as unknown as WebTransport;
 }

pkg/quic-transport/test-fixture/wt-server.ts

@@ -0,0 +1,84 @@
+import { TestServer } from "@ndn/node-transport/test-fixture/net-server";
+import { assert } from "@ndn/util";
+import { type ClientSession, createServer, type ServerSession, type WebTransportServer } from "@webtransport-bun/webtransport";
+
+/** WebTransport test server. */
+export class WtServer extends TestServer<WebTransportServer, ServerSession> {
+  public static async create(): Promise<WtServer> {
+    let self!: WtServer; // eslint-disable-line prefer-const
+
+    const port = 16384 + Math.trunc(Math.random() * 16384);
+    const server = createServer({
+      port,
+      tls: { certPem: "", keyPem: "", allowSelfSigned: true },
+      onSession: (sess) => self.onSession(sess),
+    });
+
+    self = new WtServer(server, port);
+    return self;
+  }
+
+  /** WebTransport server URI. */
+  public readonly uri: string;
+
+  constructor(server: WebTransportServer, port: number) {
+    super(server);
+    this.uri = `https://127.0.0.1:${port}`;
+  }
+
+  private waitNewSession?: () => void;
+
+  private readonly onSession = async (sess: ServerSession) => {
+    this.mClients.add(sess);
+    this.waitNewSession?.();
+    try {
+      await sess.closed;
+    } catch (err: unknown) {
+      console.warn("WtServer await sess.closed error", err);
+    } finally {
+      this.mClients.delete(sess);
+    }
+  };
+
+  public async [Symbol.asyncDispose](): Promise<void> {
+    await this.server.close();
+    const closedPromises = Array.from(this.clients, (c) => c.closed);
+    for (const client of this.clients) {
+      client.close();
+    }
+    this.mClients.clear();
+    await Promise.allSettled(closedPromises);
+  }
+
+  protected override async waitNClientsImpl(n: number, timeout: number): Promise<void> {
+    assert(!this.waitNewSession); // waitNClientsImpl is designed to be non-reentrant
+    try {
+      while (this.clients.size < n) {
+        await new Promise<void>((resolve) => {
+          this.waitNewSession = resolve;
+        });
+      }
+    } finally {
+      this.waitNewSession = undefined;
+    }
+  }
+}
+
+type CommonSession = ServerSession | ClientSession;
+
+/** Connect several WebTransport sessions and relay messages among them. */
+export function bridgeSessions(sessions: readonly CommonSession[]): void {
+  const relayDatagrams = async (src: CommonSession) => {
+    for await (const datagram of src.incomingDatagrams()) {
+      for (const dst of sessions) {
+        if (dst !== src) {
+          await dst.sendDatagram(datagram);
+        }
+      }
+    }
+  };
+
+  for (const sess of sessions) {
+    void relayDatagrams(sess);
+  }
+}

pkg/quic-transport/tests/h3-transport.t.ts

@@ -0,0 +1,43 @@
+import * as TestReopen from "@ndn/l3face/test-fixture/reopen";
+import * as TestTransport from "@ndn/l3face/test-fixture/transport";
+import { Closers } from "@ndn/util";
+import { beforeEach, expect, test } from "vitest";
+
+import { H3Transport } from "..";
+import { bridgeSessions, WtServer } from "../test-fixture/wt-server";
+
+const closers = new Closers();
+let server: WtServer;
+beforeEach(async () => {
+  server = await WtServer.create();
+  closers.push(server);
+  return closers.close;
+});
+
+test("pair", async () => {
+  const [tA, tB, sockets] = await Promise.all([
+    H3Transport.connect(server.uri, { insecureSkipVerify: true }),
+    H3Transport.connect(server.uri, { insecureSkipVerify: true }),
+    server.waitNClients(2),
+  ]);
+
+  expect(tA.toString()).toBe(`H3(${server.uri})`);
+
+  bridgeSessions(sockets);
+  TestTransport.check(await TestTransport.execute(tA, tB));
+});
+
+test("connect error", async () => {
+  const { uri } = server;
+  await server[Symbol.asyncDispose]();
+  await expect(H3Transport.connect(uri, { connectTimeout: 500 })).rejects.toThrow();
+});
+
+test("reopen", async () => {
+  const transport = await H3Transport.connect(server.uri, { insecureSkipVerify: true });
+  await TestReopen.run(
+    transport,
+    server.waitNClients,
+    (sess) => sess.close(),
+  );
+});