From 8f6d5dd6405143174a9db61315604fb05cb1315d Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 15:03:32 +0800 Subject: [PATCH] Import packages/plugin/tests/werift-turn-transport.test.ts --- .../tests/werift-turn-transport.test.ts | 124 ++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 packages/plugin/tests/werift-turn-transport.test.ts diff --git a/packages/plugin/tests/werift-turn-transport.test.ts b/packages/plugin/tests/werift-turn-transport.test.ts new file mode 100644 index 0000000..7279030 --- /dev/null +++ b/packages/plugin/tests/werift-turn-transport.test.ts @@ -0,0 +1,124 @@ +import { createServer, type AddressInfo, type Socket } from 'node:net' +import { createRequire } from 'node:module' +import { readFileSync } from 'node:fs' +import { dirname, join } from 'node:path' +import { fileURLToPath } from 'node:url' +import { describe, expect, it } from 'vitest' + +const require = createRequire(import.meta.url) + +interface WeriftStreamTransport { + connecting: Promise +} + +interface WeriftTcpTransport { + stream: WeriftStreamTransport + send: (data: Buffer) => Promise + close: () => Promise +} + +interface WeriftTransportModule { + TcpTransport: { init: (addr: [string, number]) => Promise } +} + +/** + * werift's package exports map hides its lib/ subpaths, so the transport + * module has to be resolved physically from the installed package root. + * Layout follows the pinned entry `lib/webrtc/src/index.js`. + */ +function loadWeriftTcpTransport(): WeriftTransportModule['TcpTransport'] { + const entry = require.resolve('werift') + const packageRoot = join(dirname(entry), '..', '..', '..') + const module = require(join(packageRoot, 'lib', 'common', 'src', 'transport.js')) as unknown as WeriftTransportModule + if (typeof module.TcpTransport?.init !== 'function') throw new Error(`werift TcpTransport.init is missing at ${packageRoot}`) + return module.TcpTransport +} + +const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms)) + +function trackUnhandledRejections(): { unhandled: unknown[]; stop: () => void } { + const unhandled: unknown[] = [] + const listener = (reason: unknown): void => { + unhandled.push(reason) + } + process.on('unhandledRejection', listener) + return { unhandled, stop: () => process.off('unhandledRejection', listener) } +} + +/** + * Issue #241's crash class: a lost TURN-TCP connection must never surface as + * an unhandled rejection. werift 0.26 replaced the old silent auto-redial + * with terminal failure semantics, so these tests pin that behavior. + */ +describe('werift TURN TCP transport failures (issue #241 on werift 0.26)', () => { + it('rejects init on a refused connect without an unhandled rejection', async () => { + const TcpTransport = loadWeriftTcpTransport() + const server = createServer() + await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)) + const port = (server.address() as AddressInfo).port + await new Promise(resolve => server.close(() => resolve())) + + const tracker = trackUnhandledRejections() + try { + await expect(TcpTransport.init(['127.0.0.1', port])).rejects.toThrow() + await sleep(200) + expect(tracker.unhandled).toEqual([]) + } finally { + tracker.stop() + } + }) + + it('contains a reset TURN connection without redialing or an unhandled rejection', async () => { + const TcpTransport = loadWeriftTcpTransport() + const sockets: Socket[] = [] + const server = createServer(socket => { + sockets.push(socket) + }) + await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)) + const port = (server.address() as AddressInfo).port + + const tracker = trackUnhandledRejections() + let transport: WeriftTcpTransport | undefined + try { + transport = await TcpTransport.init(['127.0.0.1', port]) + const established = transport.stream.connecting + + // The server-side accept can land after the client's connect event; + // wait for it so the reset below actually reaches werift. + const acceptDeadline = Date.now() + 3_000 + while (sockets.length === 0) { + if (Date.now() > acceptDeadline) throw new Error('server never observed the transport connection') + await sleep(10) + } + + // RST the connection — the TURN server / TUN proxy killing the socket. + // 0.26 must neither start a redial (which 0.24.4 left unobserved) nor + // leak any rejection; callers see the failure through send(). + sockets[0].destroy() + await sleep(300) + expect(tracker.unhandled).toEqual([]) + expect(transport.stream.connecting).toBe(established) + + await expect(transport.send(Buffer.from('x'))).rejects.toThrow() + await sleep(200) + expect(tracker.unhandled).toEqual([]) + } finally { + tracker.stop() + for (const socket of sockets) socket.destroy() + await transport?.close().catch(() => undefined) + await new Promise(resolve => { + server.close(() => resolve()) + for (const socket of sockets) socket.destroy() + }) + } + }) + + it('ships the 0.26 StreamTransport inside the committed Host bundle', () => { + // The bundle inlines werift through its ESM entry; assert it carries the + // rewritten StreamTransport (built-in connect timeout) so a rebuild from + // a stale 0.24.4 tree cannot silently ship the auto-redial defect. + const bundle = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'index.js'), 'utf8') + expect(bundle).toContain('connect timed out after') + expect(bundle).not.toContain('this.connecting.catch(') + }) +})