ds-harness-remote-fast/scripts/verify-packed-webrtc-runtim...

76 lines
3.9 KiB
JavaScript

// Child process for verify-packed-webrtc.mjs. Requires Node >=22.15.
import assert from 'node:assert/strict'
import { registerHooks } from 'node:module'
import { pathToFileURL } from 'node:url'
import { setTimeout as delay } from 'node:timers/promises'
assert.equal(typeof globalThis.require, 'undefined', 'smoke must run in pure ESM')
assert.equal(process.env.ELECTRON_RUN_AS_NODE, undefined, 'run with the Node runtime, not Electron')
const [entry, bundle] = process.argv.slice(2).map(path => pathToFileURL(path).href)
let nativeAttempts = 0
const hooks = registerHooks({
resolve(specifier, context, next) {
if (specifier === '@roamhq/wrtc') {
nativeAttempts++
throw new Error('native RTC intentionally unavailable in packed fallback smoke')
}
assert.notEqual(specifier, 'werift', 'packed runtime must not import external werift')
return next(specifier, context)
},
load(url, context, next) {
const result = next(url, context)
if (url === `${bundle}?transport-smoke`) {
return { ...result, source: `${typeof result.source === 'string' ? result.source : Buffer.from(result.source).toString('utf8')}\nexport { loadNodeRtcFactory, loadWeriftFactory, RtcDataChannelTransport };\nexport const weriftLoaded = () => cachedWerift !== undefined;\n` }
}
return result
},
})
const deadline = setTimeout(() => { console.error('packed WebRTC smoke timed out'); process.exit(1) }, 30_000)
const peers = []
try {
const plugin = await import(entry)
assert.equal(plugin.name, 'ds-harness-remote-fast')
assert.equal(typeof plugin.apply, 'function')
assert.equal(nativeAttempts, 0, 'package import must not initialize native RTC')
const runtime = await import(`${bundle}?transport-smoke`)
assert.equal(runtime.weriftLoaded(), false, 'werift must remain lazy until first RTC use')
const factories = await Promise.all([runtime.loadNodeRtcFactory(), runtime.loadNodeRtcFactory()])
assert.ok(nativeAttempts > 0, 'exercise real native-unavailable fallback selection')
for (const factory of factories) assert.ok(factory, 'first/concurrent fallback initialization must succeed')
assert.equal(runtime.weriftLoaded(), true)
assert.equal(await runtime.loadWeriftFactory(), await runtime.loadWeriftFactory(), 'reuse cached factory')
const received = []
const echoed = []
const a = new runtime.RtcDataChannelTransport({
role: 'initiator', factory: factories[0], iceServers: [],
onSignal: signal => b.handleSignal(signal), negotiateTimeoutMs: 8_000,
})
const b = new runtime.RtcDataChannelTransport({
role: 'responder', factory: factories[1], iceServers: [],
onSignal: signal => a.handleSignal(signal), negotiateTimeoutMs: 8_000,
})
peers.push(a, b)
a.onMessage(data => echoed.push(Buffer.from(data).toString()))
b.onMessage(data => received.push(Buffer.from(data).toString()))
await Promise.all([a.connect(), b.connect()])
await Promise.all(Array.from({ length: 8 }, (_, i) => a.send(new TextEncoder().encode(`packed-${i}`))))
while (received.length < 8) await delay(20)
await Promise.all(received.map(value => b.send(new TextEncoder().encode(`echo:${value}`))))
while (echoed.length < 8) await delay(20)
assert.equal(received.length, 8)
assert.equal(echoed.length, 8)
for (let i = 0; i < 8; i++) {
// Do not dump backing-buffer contents if a binary framing regression occurs.
assert.ok(received[i] === `packed-${i}`, `received frame ${i} payload/order mismatch`)
assert.ok(echoed[i] === `echo:packed-${i}`, `echo frame ${i} payload/order mismatch`)
}
await Promise.all(peers.map(peer => peer.close()))
for (const peer of peers) assert.equal(peer.getStats().connected, false)
console.log('pure ESM entry, lazy/native-unavailable fallback, concurrent/cache initialization and ordered bidirectional DataChannel passed')
} finally {
await Promise.all(peers.map(peer => peer.close()))
clearTimeout(deadline)
hooks.deregister()
}