Import packages/webrtc/tests/rtc-data-channel.test.ts
This commit is contained in:
parent
6e8eedfe06
commit
c91b1cfa60
|
|
@ -0,0 +1,634 @@
|
|||
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import type {
|
||||
RtcDataChannel,
|
||||
RtcIceCandidateInit,
|
||||
RtcPeerConnection,
|
||||
RtcPeerConnectionFactory,
|
||||
RtcStats,
|
||||
RtcStatsEntry,
|
||||
} from '../src/rtc-adapter.js'
|
||||
import { browserRtcFactory, stunOnlyIceServers } from '../src/rtc-adapter.js'
|
||||
import {
|
||||
detectSelectedPath,
|
||||
detectSelectedTransport,
|
||||
inspectCandidatePairs,
|
||||
inspectSelectedPath,
|
||||
RtcConnectError,
|
||||
RtcDataChannelTransport,
|
||||
type RtcDiagnosticEvent,
|
||||
} from '../src/rtc-data-channel.js'
|
||||
|
||||
const flush = () => new Promise<void>(resolve => setTimeout(resolve, 0))
|
||||
|
||||
function asStats(entries: RtcStatsEntry[]): RtcStats {
|
||||
return entries.map((entry, index) => [String(index), entry] as const)
|
||||
}
|
||||
|
||||
class FakeChannel implements RtcDataChannel {
|
||||
readonly label = 'dsh'
|
||||
readonly ordered = true
|
||||
readyState: RtcDataChannel['readyState'] = 'connecting'
|
||||
bufferedAmount = 0
|
||||
binaryType = ''
|
||||
onopen: (() => void) | null = null
|
||||
onmessage: ((event: { data: ArrayBuffer | string }) => void) | null = null
|
||||
onclose: (() => void) | null = null
|
||||
onerror: (() => void) | null = null
|
||||
onbufferedamountlow: (() => void) | null = null
|
||||
sent: (ArrayBuffer | string)[] = []
|
||||
|
||||
send(data: ArrayBuffer | string): void { this.sent.push(data) }
|
||||
close(): void { this.readyState = 'closed'; this.onclose?.() }
|
||||
open(): void { this.readyState = 'open'; this.onopen?.() }
|
||||
receive(data: ArrayBuffer | string): void { this.onmessage?.({ data }) }
|
||||
}
|
||||
|
||||
class FakePeerConnection implements RtcPeerConnection {
|
||||
connectionState = 'new'
|
||||
iceConnectionState = 'new'
|
||||
iceGatheringState = 'new'
|
||||
signalingState = 'stable'
|
||||
onconnectionstatechange: (() => void) | null = null
|
||||
oniceconnectionstatechange: (() => void) | null = null
|
||||
onicegatheringstatechange: (() => void) | null = null
|
||||
onicecandidate: ((event: { candidate: RtcIceCandidateInit | null }) => void) | null = null
|
||||
ondatachannel: ((event: { channel: RtcDataChannel }) => void) | null = null
|
||||
localDescription: { type: 'offer' | 'answer'; sdp?: string } | undefined
|
||||
remoteDescription: { type: 'offer' | 'answer'; sdp?: string } | undefined
|
||||
channels: FakeChannel[] = []
|
||||
candidates: RtcIceCandidateInit[] = []
|
||||
stats: RtcStatsEntry[] = []
|
||||
|
||||
createDataChannel(): RtcDataChannel {
|
||||
const channel = new FakeChannel()
|
||||
this.channels.push(channel)
|
||||
return channel
|
||||
}
|
||||
async createOffer(): Promise<{ type: 'offer'; sdp?: string }> { return { type: 'offer', sdp: 'v=0 offer' } }
|
||||
async createAnswer(): Promise<{ type: 'answer'; sdp?: string }> { return { type: 'answer', sdp: 'v=0 answer' } }
|
||||
async setLocalDescription(description: { type: 'offer' | 'answer'; sdp?: string }): Promise<void> { this.localDescription = description }
|
||||
async setRemoteDescription(description: { type: 'offer' | 'answer'; sdp?: string }): Promise<void> { this.remoteDescription = description }
|
||||
async addIceCandidate(candidate: RtcIceCandidateInit): Promise<void> { this.candidates.push(candidate) }
|
||||
async getStats(): Promise<Iterable<readonly [string, RtcStatsEntry]>> {
|
||||
return this.stats.map((entry, index) => [String(index), entry] as const)
|
||||
}
|
||||
close(): void { this.connectionState = 'closed' }
|
||||
emitIceCandidate(candidate: RtcIceCandidateInit | null): void { this.onicecandidate?.({ candidate }) }
|
||||
emitDataChannel(channel: RtcDataChannel): void { this.ondatachannel?.({ channel }) }
|
||||
}
|
||||
|
||||
function factoryFor(pc: FakePeerConnection): RtcPeerConnectionFactory {
|
||||
return { create: () => pc }
|
||||
}
|
||||
|
||||
function p2pStats(): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: 'host', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'srflx', id: 'rc' },
|
||||
{ type: 'candidate-pair', selected: true, nominated: true, localCandidateId: 'lc', remoteCandidateId: 'rc' },
|
||||
]
|
||||
}
|
||||
|
||||
function lanStats(): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: 'host', address: '192.168.1.20', port: 51_001, protocol: 'udp', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'host', address: '192.168.1.30', port: 51_002, protocol: 'udp', id: 'rc' },
|
||||
{
|
||||
type: 'candidate-pair', id: 'cp', state: 'succeeded', localCandidateId: 'lc', remoteCandidateId: 'rc',
|
||||
currentRoundTripTime: 0.0124, availableOutgoingBitrate: 8_500_000, bytesSent: 2_048, bytesReceived: 4_096,
|
||||
},
|
||||
{ type: 'transport', selectedCandidatePairId: 'cp' },
|
||||
]
|
||||
}
|
||||
|
||||
function privatePeerReflexiveLanStats(): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: 'host', address: '192.168.31.225', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'prflx', address: '192.168.31.9', id: 'rc' },
|
||||
{ type: 'candidate-pair', selected: true, nominated: true, localCandidateId: 'lc', remoteCandidateId: 'rc' },
|
||||
]
|
||||
}
|
||||
|
||||
function publicPeerReflexiveP2pStats(): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: 'host', address: '192.168.31.225', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'prflx', address: '203.0.113.9', id: 'rc' },
|
||||
{ type: 'candidate-pair', selected: true, nominated: true, localCandidateId: 'lc', remoteCandidateId: 'rc' },
|
||||
]
|
||||
}
|
||||
|
||||
function hiddenPeerReflexiveLanStats(): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: 'host', address: '192.168.31.225', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'prflx', id: 'rc' },
|
||||
{ type: 'candidate-pair', selected: true, nominated: true, localCandidateId: 'lc', remoteCandidateId: 'rc' },
|
||||
]
|
||||
}
|
||||
|
||||
function tailscaleP2pStats(localType: 'host' | 'prflx' = 'prflx'): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: localType, id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'host', address: 'fd7a:115c:a1e0::c', id: 'rc' },
|
||||
{ type: 'candidate-pair', selected: true, nominated: true, localCandidateId: 'lc', remoteCandidateId: 'rc' },
|
||||
]
|
||||
}
|
||||
|
||||
function turnStats(): RtcStatsEntry[] {
|
||||
return [
|
||||
{ type: 'local-candidate', candidateType: 'relay', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'host', id: 'rc' },
|
||||
{ type: 'candidate-pair', selected: true, localCandidateId: 'lc', remoteCandidateId: 'rc' },
|
||||
]
|
||||
}
|
||||
|
||||
describe('detectSelectedTransport', () => {
|
||||
it('classifies selected candidate pairs as LAN, P2P or TURN', async () => {
|
||||
await runScenarios([
|
||||
{
|
||||
name: 'classifies a selected private host-to-host pair as LAN on the wire',
|
||||
run: () => {
|
||||
expect(detectSelectedPath(asStats(lanStats()))).toEqual({ transport: 'lan', mode: 'LAN' })
|
||||
expect(detectSelectedTransport(asStats(lanStats()))).toBe('lan')
|
||||
expect(inspectSelectedPath(asStats(lanStats()))).toMatchObject({
|
||||
localCandidateType: 'host',
|
||||
remoteCandidateType: 'host',
|
||||
localAddress: '192.168.1.20:51001',
|
||||
remoteAddress: '192.168.1.30:51002',
|
||||
protocol: 'udp',
|
||||
currentRoundTripTimeMs: 12,
|
||||
availableOutgoingBitrate: 8_500_000,
|
||||
bytesSent: 2_048,
|
||||
bytesReceived: 4_096,
|
||||
})
|
||||
expect(inspectCandidatePairs(asStats(lanStats()))).toMatchObject({
|
||||
total: 1,
|
||||
byState: { succeeded: 1 },
|
||||
byLocalType: { host: 1 },
|
||||
byRemoteType: { host: 1 },
|
||||
byLocalScope: { private: 1 },
|
||||
byRemoteScope: { private: 1 },
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'classifies a private host-to-peer-reflexive pair as LAN',
|
||||
run: () => {
|
||||
expect(detectSelectedPath(asStats(privatePeerReflexiveLanStats()))).toEqual({
|
||||
transport: 'lan',
|
||||
mode: 'LAN',
|
||||
})
|
||||
expect(inspectSelectedPath(asStats(privatePeerReflexiveLanStats()))).toMatchObject({
|
||||
localCandidateType: 'host',
|
||||
remoteCandidateType: 'prflx',
|
||||
localAddressScope: 'private',
|
||||
remoteAddressScope: 'private',
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'keeps a public peer-reflexive pair classified as P2P',
|
||||
run: () => {
|
||||
expect(detectSelectedPath(asStats(publicPeerReflexiveP2pStats()))).toEqual({
|
||||
transport: 'p2p',
|
||||
mode: 'P2P',
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'classifies an address-hidden peer-reflexive candidate beside a private host as LAN',
|
||||
run: () => {
|
||||
expect(detectSelectedPath(asStats(hiddenPeerReflexiveLanStats()))).toEqual({
|
||||
transport: 'lan',
|
||||
mode: 'LAN',
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'classifies a loopback host beside an address-hidden prflx candidate as LAN',
|
||||
run: () => {
|
||||
expect(
|
||||
detectSelectedPath(
|
||||
asStats([
|
||||
{ type: 'local-candidate', candidateType: 'prflx', id: 'lc' },
|
||||
{ type: 'remote-candidate', candidateType: 'host', address: '127.0.0.1', id: 'rc' },
|
||||
{
|
||||
type: 'candidate-pair',
|
||||
selected: true,
|
||||
nominated: true,
|
||||
localCandidateId: 'lc',
|
||||
remoteCandidateId: 'rc',
|
||||
},
|
||||
]),
|
||||
),
|
||||
).toEqual({ transport: 'lan', mode: 'LAN' })
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'classifies a Tailscale IPv6 overlay pair as P2P',
|
||||
run: () => {
|
||||
expect(detectSelectedPath(asStats(tailscaleP2pStats()))).toEqual({ transport: 'p2p', mode: 'P2P' })
|
||||
expect(inspectSelectedPath(asStats(tailscaleP2pStats()))).toMatchObject({
|
||||
localCandidateType: 'prflx',
|
||||
remoteCandidateType: 'host',
|
||||
remoteAddressScope: 'cgnat',
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'does not treat host-to-host Tailscale overlay candidates as LAN',
|
||||
run: () => {
|
||||
expect(detectSelectedPath(asStats(tailscaleP2pStats('host')))).toEqual({
|
||||
transport: 'p2p',
|
||||
mode: 'P2P',
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'detects p2p from a selected host/srflx candidate pair',
|
||||
run: () => {
|
||||
expect(detectSelectedTransport(asStats(p2pStats()))).toBe('p2p')
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'detects turn when any selected candidate is a relay candidate',
|
||||
run: () => {
|
||||
expect(detectSelectedTransport(asStats(turnStats()))).toBe('turn')
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'returns undefined when no selected pair exists',
|
||||
run: () => {
|
||||
expect(
|
||||
detectSelectedTransport(asStats([{ type: 'local-candidate', candidateType: 'host', id: 'lc' }])),
|
||||
).toBeUndefined()
|
||||
},
|
||||
},
|
||||
])
|
||||
}, 50000)
|
||||
|
||||
})
|
||||
|
||||
describe('stunOnlyIceServers', () => {
|
||||
it('keeps direct STUN URLs and strips TURN URLs and credentials', () => {
|
||||
expect(stunOnlyIceServers([
|
||||
{
|
||||
urls: [
|
||||
'stun:turn.example.com:3478',
|
||||
'turn:turn.example.com:3478?transport=udp',
|
||||
'turns:turn.example.com:5349?transport=tcp',
|
||||
],
|
||||
username: 'turn-user',
|
||||
credential: 'turn-secret',
|
||||
},
|
||||
{ urls: 'stuns:stun.example.com:5349' },
|
||||
{ urls: 'turn:relay.example.com:3478?transport=tcp', username: 'relay', credential: 'secret' },
|
||||
])).toEqual([
|
||||
{ urls: ['stun:turn.example.com:3478'] },
|
||||
{ urls: 'stuns:stun.example.com:5349' },
|
||||
])
|
||||
})
|
||||
})
|
||||
|
||||
describe('RtcDataChannelTransport initiator', () => {
|
||||
it('reports LAN for a private host-to-host data path', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
pc.stats = lanStats()
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
})
|
||||
const connecting = transport.connect()
|
||||
await flush()
|
||||
transport.handleSignal({ type: 'answer', sdp: 'v=0 answer' })
|
||||
await flush()
|
||||
pc.channels[0]!.open()
|
||||
await connecting
|
||||
expect(transport.selectedTransport()).toBe('lan')
|
||||
expect(transport.selectedPathMode()).toBe('LAN')
|
||||
expect(transport.getStats().mode).toBe('LAN')
|
||||
await expect(transport.connectionDetails()).resolves.toMatchObject({
|
||||
mode: 'LAN',
|
||||
connectionState: 'new',
|
||||
iceConnectionState: 'new',
|
||||
dataChannelState: 'open',
|
||||
localAddress: '192.168.1.20:51001',
|
||||
remoteAddress: '192.168.1.30:51002',
|
||||
currentRoundTripTimeMs: 12,
|
||||
})
|
||||
await transport.close()
|
||||
})
|
||||
|
||||
it('waits for native stats to expose the selected LAN candidate pair', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
const getStats = vi.spyOn(pc, 'getStats')
|
||||
.mockResolvedValueOnce(asStats([]))
|
||||
.mockResolvedValue(asStats(lanStats()))
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
})
|
||||
const connecting = transport.connect()
|
||||
await flush()
|
||||
transport.handleSignal({ type: 'answer', sdp: 'v=0 answer' })
|
||||
await flush()
|
||||
pc.channels[0]!.open()
|
||||
await connecting
|
||||
|
||||
expect(getStats).toHaveBeenCalledTimes(2)
|
||||
expect(transport.selectedPathMode()).toBe('LAN')
|
||||
expect(transport.getStats()).toMatchObject({ mode: 'LAN', connected: true })
|
||||
await transport.close()
|
||||
})
|
||||
|
||||
it('creates an offer and resolves with p2p once the data channel opens', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
pc.stats = p2pStats()
|
||||
const signals: unknown[] = []
|
||||
const diagnostics: RtcDiagnosticEvent[] = []
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: signal => signals.push(signal),
|
||||
onDiagnostic: event => diagnostics.push(event),
|
||||
})
|
||||
let connected = false
|
||||
const connecting = transport.connect().then(() => { connected = true })
|
||||
await flush()
|
||||
|
||||
expect(pc.channels).toHaveLength(1)
|
||||
expect(pc.localDescription?.type).toBe('offer')
|
||||
expect(signals).toEqual([{ type: 'offer', sdp: 'v=0 offer' }])
|
||||
|
||||
const hostCandidate = { candidate: 'candidate:1 1 udp 2130706431 192.168.1.20 5000 typ host generation 0' }
|
||||
pc.emitIceCandidate(hostCandidate)
|
||||
expect(signals.at(-1)).toEqual({ type: 'ice', candidate: hostCandidate })
|
||||
expect(diagnostics).toContainEqual(expect.objectContaining({
|
||||
type: 'local-candidate',
|
||||
candidate: expect.objectContaining({
|
||||
candidateType: 'host',
|
||||
protocol: 'udp',
|
||||
addressFamily: 'ipv4',
|
||||
addressScope: 'private',
|
||||
}),
|
||||
}))
|
||||
|
||||
transport.handleSignal({ type: 'answer', sdp: 'v=0 answer' })
|
||||
await flush()
|
||||
expect(pc.remoteDescription?.type).toBe('answer')
|
||||
|
||||
pc.channels[0]!.open()
|
||||
await connecting
|
||||
expect(connected).toBe(true)
|
||||
expect(transport.selectedTransport()).toBe('p2p')
|
||||
expect(transport.getStats()).toMatchObject({ mode: 'P2P', connected: true })
|
||||
expect(transport.diagnostics()).toMatchObject({
|
||||
localCandidates: { total: 1, byType: { host: 1 }, byFamily: { ipv4: 1 }, byScope: { private: 1 } },
|
||||
candidatePairs: { total: 1, selected: 1, byState: { selected: 1 } },
|
||||
selectedPath: { transport: 'p2p', mode: 'P2P' },
|
||||
})
|
||||
|
||||
await transport.send(new Uint8Array([1, 2, 3]))
|
||||
expect(pc.channels[0]!.sent).toHaveLength(1)
|
||||
await transport.close()
|
||||
})
|
||||
|
||||
it('keeps an active or unmonitored send queue connected', async () => {
|
||||
await runScenarios([
|
||||
{
|
||||
name: 'does not treat continued sends as a stalled DataChannel queue',
|
||||
run: async () => {
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
const pc = new FakePeerConnection()
|
||||
pc.stats = lanStats()
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
sendTimeoutMs: 5_000,
|
||||
})
|
||||
const connecting = transport.connect()
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
transport.handleSignal({ type: 'answer', sdp: 'v=0 answer' })
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
const channel = pc.channels[0]!
|
||||
channel.open()
|
||||
await connecting
|
||||
|
||||
channel.bufferedAmount = 10
|
||||
await transport.send(new Uint8Array([1]))
|
||||
await vi.advanceTimersByTimeAsync(4_000)
|
||||
|
||||
// Loading a conversation sends more requests while earlier writes are
|
||||
// still draining. The newer send must refresh the watchdog baseline;
|
||||
// it is evidence of active traffic, not evidence that the first write
|
||||
// has been stuck for five seconds.
|
||||
channel.bufferedAmount = 20
|
||||
await transport.send(new Uint8Array([2]))
|
||||
await vi.advanceTimersByTimeAsync(1_100)
|
||||
expect(transport.getStats()).toMatchObject({ mode: 'LAN', connected: true })
|
||||
|
||||
channel.bufferedAmount = 0
|
||||
await vi.advanceTimersByTimeAsync(4_000)
|
||||
expect(transport.getStats()).toMatchObject({ mode: 'LAN', connected: true })
|
||||
await transport.close()
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
},
|
||||
},
|
||||
{
|
||||
name: 'does not infer a dead connection from bufferedAmount by default',
|
||||
run: async () => {
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
const pc = new FakePeerConnection()
|
||||
pc.stats = lanStats()
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
})
|
||||
const connecting = transport.connect()
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
transport.handleSignal({ type: 'answer', sdp: 'v=0 answer' })
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
const channel = pc.channels[0]!
|
||||
channel.open()
|
||||
await connecting
|
||||
|
||||
// React Native may retain a positive bufferedAmount even after SCTP has
|
||||
// delivered the frame. It is not an acknowledgement or liveness signal.
|
||||
channel.bufferedAmount = 64 * 1024
|
||||
await transport.send(new Uint8Array([1, 2, 3]))
|
||||
await vi.advanceTimersByTimeAsync(60_000)
|
||||
expect(transport.getStats()).toMatchObject({ mode: 'LAN', connected: true })
|
||||
await transport.close()
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
},
|
||||
},
|
||||
])
|
||||
}, 10000)
|
||||
|
||||
it('detects turn from the selected candidate pair', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
pc.stats = turnStats()
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
})
|
||||
const connecting = transport.connect()
|
||||
await flush()
|
||||
transport.handleSignal({ type: 'answer', sdp: 'v=0 answer' })
|
||||
await flush()
|
||||
pc.channels[0]!.open()
|
||||
await connecting
|
||||
expect(transport.selectedTransport()).toBe('turn')
|
||||
expect(transport.getStats().mode).toBe('TURN')
|
||||
await transport.close()
|
||||
})
|
||||
|
||||
it('rejects on negotiation timeout', async () => {
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
const pc = new FakePeerConnection()
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
negotiateTimeoutMs: 1000,
|
||||
})
|
||||
let caught: Error | undefined
|
||||
const connecting = transport.connect().catch((error: Error) => { caught = error })
|
||||
await vi.advanceTimersByTimeAsync(1100)
|
||||
await connecting
|
||||
expect(caught).toMatchObject({ code: 'RTC_CONNECT_TIMEOUT' })
|
||||
expect(transport.getStats().connected).toBe(false)
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('RtcDataChannelTransport responder', () => {
|
||||
it('answers an offer and resolves when the remote data channel opens', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
pc.stats = p2pStats()
|
||||
const signals: unknown[] = []
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'responder',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: signal => signals.push(signal),
|
||||
})
|
||||
let connected = false
|
||||
const connecting = transport.connect().then(() => { connected = true })
|
||||
|
||||
transport.handleSignal({ type: 'offer', sdp: 'v=0 offer' })
|
||||
await flush()
|
||||
expect(pc.remoteDescription?.type).toBe('offer')
|
||||
expect(signals).toEqual([{ type: 'answer', sdp: 'v=0 answer' }])
|
||||
|
||||
const channel = new FakeChannel()
|
||||
pc.emitDataChannel(channel)
|
||||
channel.open()
|
||||
await connecting
|
||||
expect(connected).toBe(true)
|
||||
|
||||
const received: Uint8Array[] = []
|
||||
transport.onMessage(data => received.push(data))
|
||||
channel.receive(new Uint8Array([9, 8, 7]).buffer)
|
||||
expect(received).toHaveLength(1)
|
||||
await transport.close()
|
||||
})
|
||||
|
||||
it('buffers trickle ICE until the offer is processed', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
const diagnostics: RtcDiagnosticEvent[] = []
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'responder',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
onDiagnostic: event => diagnostics.push(event),
|
||||
})
|
||||
const connecting = expect(transport.connect()).rejects.toThrow('closed')
|
||||
const early: RtcIceCandidateInit = {
|
||||
candidate: 'candidate:1 1 udp 1694498815 203.0.113.8 5002 typ srflx raddr 192.168.1.20 rport 5000',
|
||||
sdpMid: '0',
|
||||
sdpMLineIndex: 0,
|
||||
}
|
||||
transport.handleSignal({ type: 'ice', candidate: early })
|
||||
await flush()
|
||||
expect(pc.candidates).toHaveLength(0) // buffered, remote description not set yet
|
||||
expect(diagnostics).toContainEqual(expect.objectContaining({
|
||||
type: 'remote-candidate',
|
||||
action: 'buffered',
|
||||
candidate: expect.objectContaining({
|
||||
candidateType: 'srflx',
|
||||
addressFamily: 'ipv4',
|
||||
addressScope: 'public',
|
||||
relatedAddressScope: 'private',
|
||||
}),
|
||||
}))
|
||||
|
||||
transport.handleSignal({ type: 'offer', sdp: 'v=0 offer' })
|
||||
await flush()
|
||||
expect(pc.candidates).toHaveLength(1)
|
||||
expect(transport.diagnostics().remoteCandidates).toMatchObject({
|
||||
total: 1,
|
||||
byType: { srflx: 1 },
|
||||
byScope: { public: 1 },
|
||||
})
|
||||
await transport.close()
|
||||
await connecting
|
||||
})
|
||||
|
||||
it('is an idempotent close', async () => {
|
||||
const pc = new FakePeerConnection()
|
||||
const transport = new RtcDataChannelTransport({
|
||||
role: 'responder',
|
||||
factory: factoryFor(pc),
|
||||
onSignal: () => undefined,
|
||||
})
|
||||
await transport.close()
|
||||
await transport.close()
|
||||
expect(transport.getStats().connected).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('RtcConnectError', () => {
|
||||
it('carries a stable code', () => {
|
||||
expect(new RtcConnectError('RTC_CONNECT_TIMEOUT', 'x').code).toBe('RTC_CONNECT_TIMEOUT')
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
describe('browser/native RTC policy', () => {
|
||||
it('passes relay-only ICE to the native peer connection', () => {
|
||||
let configuration: unknown
|
||||
class NativePeerConnection {
|
||||
constructor(value: unknown) { configuration = value }
|
||||
}
|
||||
vi.stubGlobal('RTCPeerConnection', NativePeerConnection)
|
||||
try {
|
||||
new RtcDataChannelTransport({
|
||||
role: 'initiator',
|
||||
factory: browserRtcFactory(),
|
||||
iceTransportPolicy: 'relay',
|
||||
iceServers: [{ urls: 'turn:turn.example.test' }],
|
||||
onSignal: () => {},
|
||||
})
|
||||
expect(configuration).toEqual({
|
||||
iceTransportPolicy: 'relay',
|
||||
iceServers: [{ urls: 'turn:turn.example.test' }],
|
||||
})
|
||||
} finally {
|
||||
vi.unstubAllGlobals()
|
||||
}
|
||||
})
|
||||
})
|
||||
Loading…
Reference in New Issue