Initial Commit

packages/networking/drive/drive-mesh/tests/helpers/fake-transport.ts

@@ -0,0 +1,143 @@
+/**
+ * In-memory `DriveTransport` for tests.
+ *
+ * Modelled on the FakeWebSocketBroker pattern from drive-webrtc: a
+ * single `Broker` object knows about every transport instance, so
+ * an `advertise` call on transport A reaches every subscriber on
+ * transport B that is registered for the same broker.
+ *
+ * `requestChunk` resolves with the bytes the broker has stored under
+ * `(peerId, fileId, chunkId)`. Tests stage bytes via `broker.serve(...)`.
+ */
+
+import type { PeerId } from "@suaveplan/types";
+import type {
+    AdvertisementHandler,
+    ChunkAdvertisement,
+    DriveTransport,
+    Unsubscribe,
+} from "../../src/types/index.js";
+
+export interface ChunkBytesSource {
+    /** Bytes to return, OR a thrown error / promise rejection. */
+    readonly bytes?: Uint8Array;
+    readonly throwReason?: string;
+    /** Optional delay in ms before resolving. */
+    readonly delayMs?: number;
+}
+
+export class Broker {
+    public readonly transports = new Set<FakeDriveTransport>();
+    public readonly chunkStore = new Map<string, ChunkBytesSource>();
+
+    public serve(
+        peerId: PeerId,
+        fileId: string,
+        chunkId: number,
+        source: ChunkBytesSource
+    ): void {
+        this.chunkStore.set(`${peerId}:${fileId}:${chunkId}`, source);
+    }
+
+    public deliverAdvertisement(
+        senderId: PeerId,
+        advert: ChunkAdvertisement
+    ): void {
+        for (const transport of this.transports) {
+            for (const handler of transport.handlers) {
+                if (transport.localPeerId === senderId) continue;
+                handler(senderId, advert);
+            }
+        }
+    }
+}
+
+export class FakeDriveTransport implements DriveTransport {
+    public readonly id: string;
+    public readonly localPeerId: PeerId;
+    public readonly handlers = new Set<AdvertisementHandler>();
+    public readonly knownPeers = new Set<PeerId>();
+    readonly #broker: Broker;
+
+    public constructor(args: {
+        readonly broker: Broker;
+        readonly localPeerId: PeerId;
+        readonly id?: string;
+    }) {
+        this.id = args.id ?? "fake";
+        this.localPeerId = args.localPeerId;
+        this.#broker = args.broker;
+        this.#broker.transports.add(this);
+    }
+
+    public addKnownPeer(peerId: PeerId): void {
+        this.knownPeers.add(peerId);
+    }
+
+    public async requestChunk(
+        peerId: PeerId,
+        fileId: string,
+        chunkId: number,
+        signal?: AbortSignal
+    ): Promise<Uint8Array> {
+        const key = `${peerId}:${fileId}:${chunkId}`;
+        const source = this.#broker.chunkStore.get(key);
+        if (source === undefined) {
+            throw new Error(`no chunk staged at ${key}`);
+        }
+        if (source.delayMs !== undefined && source.delayMs > 0) {
+            await new Promise<void>((resolve, reject) => {
+                const handle = setTimeout(() => {
+                    signal?.removeEventListener("abort", onAbort);
+                    resolve();
+                }, source.delayMs);
+                const onAbort = (): void => {
+                    clearTimeout(handle);
+                    reject(new Error("aborted"));
+                };
+                if (signal?.aborted) {
+                    onAbort();
+                } else {
+                    signal?.addEventListener("abort", onAbort, { once: true });
+                }
+            });
+        }
+        if (source.throwReason !== undefined) {
+            throw new Error(source.throwReason);
+        }
+        if (source.bytes === undefined) {
+            throw new Error(`no bytes staged at ${key}`);
+        }
+        return source.bytes;
+    }
+
+    public async advertise(
+        peerId: PeerId,
+        advert: ChunkAdvertisement
+    ): Promise<void> {
+        // Deliver to every other transport's subscribers via the broker.
+        for (const transport of this.#broker.transports) {
+            if (transport === this) continue;
+            if (transport.localPeerId !== peerId) continue;
+            for (const handler of transport.handlers) {
+                handler(this.localPeerId, advert);
+            }
+        }
+    }
+
+    public onAdvertisement(handler: AdvertisementHandler): Unsubscribe {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+
+    public peers(): Iterable<PeerId> {
+        return this.knownPeers;
+    }
+
+    public dispose(): void {
+        this.#broker.transports.delete(this);
+        this.handlers.clear();
+    }
+}