ds-harness-remote-fast/packages/plugin/tests/werift-turn-transport.test.ts

125 lines
4.9 KiB
TypeScript

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<unknown>
}
interface WeriftTcpTransport {
stream: WeriftStreamTransport
send: (data: Buffer) => Promise<void>
close: () => Promise<void>
}
interface WeriftTransportModule {
TcpTransport: { init: (addr: [string, number]) => Promise<WeriftTcpTransport> }
}
/**
* 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<void>(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<void>(resolve => server.listen(0, '127.0.0.1', resolve))
const port = (server.address() as AddressInfo).port
await new Promise<void>(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<void>(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<void>(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(')
})
})