Shade/packages/shade-sdk/tests/webrtc-failover.test.ts

/**
 * V3.11 acceptance criterion: P2P-død → HTTP innen 5 s uten meldingstap.
 *
 * We simulate WebRTC failure by injecting a factory whose every peer
 * connection refuses to open. The MultiTransportFallback should
 * demote to HTTP, and the upload should complete via the HTTP
 * receiver-side route exactly as if WebRTC was never configured.
 */
import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import {
  createShade,
  type Shade,
  type TransferHandle,
  type TransferResult,
} from '../src/index.js';
import {
  createPrekeyServer,
  MemoryPrekeyStore,
  PrekeyServerEvents,
} from '@shade/server';
import { SubtleCryptoProvider } from '@shade/crypto-web';
import { sha256Once } from '@shade/streams';
import type {
  IDataChannel,
  IPeerConnection,
  IRtcFactory,
  ShadeIceCandidate,
  ShadeRtcConfig,
  ShadeRtcConnectionState,
  ShadeSessionDescription,
} from '@shade/transport-webrtc';

const crypto = new SubtleCryptoProvider();

/** Factory whose PCs synthesize an SDP but never emit `'open'` on the data
 *  channel. Triggers a connect timeout, which the multi-fallback treats
 *  as a transport error and demotes the WebRTC layer. */
class BrokenRtcFactory implements IRtcFactory {
  createPeerConnection(_config: ShadeRtcConfig): IPeerConnection {
    return new BrokenPeerConnection();
  }
}

class BrokenPeerConnection implements IPeerConnection {
  connectionState: ShadeRtcConnectionState | string = 'new';
  iceConnectionState = 'new';
  private dc: BrokenDataChannel | null = null;

  createDataChannel(label: string): IDataChannel {
    if (this.dc !== null) return this.dc;
    this.dc = new BrokenDataChannel(label);
    return this.dc;
  }
  async createOffer(): Promise<ShadeSessionDescription> {
    return { type: 'offer', sdp: 'v=0\nbroken' };
  }
  async createAnswer(): Promise<ShadeSessionDescription> {
    return { type: 'answer', sdp: 'v=0\nbroken' };
  }
  async setLocalDescription(_desc: ShadeSessionDescription): Promise<void> {}
  async setRemoteDescription(_desc: ShadeSessionDescription): Promise<void> {}
  async addIceCandidate(_c: ShadeIceCandidate | null): Promise<void> {}
  close(): void {
    this.connectionState = 'closed';
    if (this.dc !== null) this.dc.close();
  }
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  addEventListener(_event: string, _cb: any): void {
    // Never fires open / datachannel — provoking the connect timeout.
  }
  removeEventListener(): void {}
}

class BrokenDataChannel implements IDataChannel {
  readyState: 'connecting' | 'open' | 'closing' | 'closed' = 'connecting';
  binaryType: 'arraybuffer' | 'blob' = 'arraybuffer';
  bufferedAmount = 0;
  constructor(public readonly label: string) {}
  send(_data: ArrayBuffer | Uint8Array): void {
    throw new Error('broken DC');
  }
  close(): void {
    this.readyState = 'closed';
  }
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  addEventListener(_event: string, _cb: any): void {}
  removeEventListener(): void {}
}

interface Rig {
  alice: Shade;
  bob: Shade;
  prekeyStop: () => void;
  aliceServerStop: () => void;
  bobServerStop: () => void;
}

async function startPrekeyServer(): Promise<{ url: string; stop: () => void }> {
  const events = new PrekeyServerEvents();
  const server = createPrekeyServer({
    crypto,
    store: new MemoryPrekeyStore(),
    disableRateLimit: true,
    events,
  });
  // Port 0 lets the OS hand out a free one. This guessed inside a 500-wide
  // range and hoped — and several files here guessed inside the SAME range,
  // so with test files serving in parallel the collision arrived about a
  // quarter of the time as EADDRINUSE.
  const handle = Bun.serve({ port: 0, fetch: server.fetch });
  const port = handle.port;
  return { url: `http://localhost:${port}`, stop: () => handle.stop() };
}

async function setupRig(connectTimeoutMs: number): Promise<Rig> {
  const prekey = await startPrekeyServer();
  const alice = await createShade({ prekeyServer: prekey.url, address: 'alice' });
  const bob = await createShade({ prekeyServer: prekey.url, address: 'bob' });

  const baseUrls = new Map<string, string>();
  const resolveBaseUrl = async (addr: string): Promise<string> => {
    const url = baseUrls.get(addr);
    if (url === undefined) throw new Error(`unknown peer ${addr}`);
    return url;
  };
  alice.configureTransfers({ resolveBaseUrl });
  bob.configureTransfers({ resolveBaseUrl });

  const broken = new BrokenRtcFactory();
  alice.configureWebRTC({ factory: broken, connectTimeoutMs });
  bob.configureWebRTC({ factory: broken, connectTimeoutMs });

  const bobApp = await bob.transferRoute();
  // Port 0 lets the OS hand out a free one. This guessed inside a 500-wide
  // range and hoped — and several files here guessed inside the SAME range,
  // so with test files serving in parallel the collision arrived about a
  // quarter of the time as EADDRINUSE.
  const bobServer = Bun.serve({ port: 0, fetch: bobApp.fetch });
  const bobPort = bobServer.port;
  baseUrls.set('bob', `http://localhost:${bobPort}`);

  const aliceApp = await alice.transferRoute();
  // Port 0 lets the OS hand out a free one. This guessed inside a 500-wide
  // range and hoped — and several files here guessed inside the SAME range,
  // so with test files serving in parallel the collision arrived about a
  // quarter of the time as EADDRINUSE.
  const aliceServer = Bun.serve({ port: 0, fetch: aliceApp.fetch });
  const alicePort = aliceServer.port;
  baseUrls.set('alice', `http://localhost:${alicePort}`);

  return {
    alice,
    bob,
    prekeyStop: prekey.stop,
    aliceServerStop: () => aliceServer.stop(),
    bobServerStop: () => bobServer.stop(),
  };
}

async function teardownRig(rig: Rig | undefined): Promise<void> {
  // Tolerates a rig that never finished being built. When setupRig threw —
  // EADDRINUSE, before ports stopped being guessed — this ran anyway and died
  // on `rig.alice`, so one failure became two and the second one, a TypeError
  // in teardown, is what you saw first. Cleanup must never be the loudest
  // thing in a failing test.
  if (!rig) return;
  await rig.alice?.shutdown().catch(() => {});
  await rig.bob?.shutdown().catch(() => {});
  try { rig.bobServerStop?.(); } catch { /* already gone */ }
  try { rig.aliceServerStop?.(); } catch { /* already gone */ }
  try { rig.prekeyStop?.(); } catch { /* already gone */ }
}

function hex(b: Uint8Array): string {
  return Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('');
}

describe('V3.11 P2P → HTTP failover', () => {
  let rig: Rig;
  beforeAll(async () => {
    // 2s timeout — well within the 5s acceptance budget.
    rig = await setupRig(2_000);
  });
  afterAll(async () => {
    await teardownRig(rig);
  });

  test(
    'WebRTC primary fails → HTTP fallback delivers without message loss',
    async () => {
      const input = crypto.randomBytes(64 * 1024);

      let resolveRecv!: (h: TransferHandle) => void;
      const recvHandlePromise = new Promise<TransferHandle>((r) => {
        resolveRecv = r;
      });
      const unsubscribe = await rig.bob.onIncomingTransfer(async (incoming) => {
        const h = await incoming.accept({ output: { kind: 'buffer' } });
        resolveRecv(h);
      });

      const t0 = performance.now();
      const handle = await rig.alice.upload({
        to: 'bob',
        input,
        metadata: { name: 'failover.bin' },
      });
      const recvHandle = await recvHandlePromise;
      const [senderResult, recvResult] = await Promise.all([
        handle.done(),
        recvHandle.done(),
      ]);
      const elapsed = performance.now() - t0;
      unsubscribe();

      const received =
        (recvResult as TransferResult & { bytes?: Uint8Array }).bytes ?? new Uint8Array();
      expect(received).toEqual(input);
      expect(senderResult.sha256).toBe(hex(sha256Once(input)));

      const runtime = rig.alice.getWebRtcRuntime();
      expect(runtime!.fallback.activeName).toBe('http');
      expect(runtime!.fallback.hasFallenBack).toBe(true);
      expect(runtime!.fallback.failures.length).toBeGreaterThanOrEqual(1);

      // V3.11 acceptance: failover within 5 s.
      expect(elapsed).toBeLessThan(5_000);
    },
    15_000,
  );
});