import { EventEmitter } from 'events'; import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import { PCEvents } from './PCTransport'; import { PCTransportManager, PCTransportState } from './PCTransportManager'; import { ConnectionErrorReason } from './errors'; /** * Yield to the microtask queue so any then/catch handlers chained to a promise * have a chance to run. Sufficient for "is this promise still pending right * now?" assertions; nothing in these tests depends on real elapsed time. */ const flushMicrotasks = () => Promise.resolve(); class StubPC { iceConnectionState: RTCIceConnectionState = 'new'; signalingState: RTCSignalingState = 'stable'; connectionState: RTCPeerConnectionState = 'new'; onicecandidate: ((ev: RTCPeerConnectionIceEvent) => void) | null = null; onicecandidateerror: ((ev: Event) => void) | null = null; oniceconnectionstatechange: (() => void) | null = null; onsignalingstatechange: (() => void) | null = null; onconnectionstatechange: (() => void) | null = null; ondatachannel: ((ev: RTCDataChannelEvent) => void) | null = null; ontrack: ((ev: RTCTrackEvent) => void) | null = null; getTransceivers() { return []; } getSenders() { return []; } close() {} setConfiguration() {} } class FakePublisher extends EventEmitter { latestOfferId = 0; latestAcknowledgedOfferId = 0; negotiate = vi.fn(async (_onError?: (e: Error) => void) => {}); /** Simulate a publisher offer cycle: bump latestOfferId. */ startOffer() { this.latestOfferId += 1; return this.latestOfferId; } /** Simulate a successful answer for the given offerId. */ answer(offerId: number) { this.latestAcknowledgedOfferId = offerId; this.emit(PCEvents.OfferAnswered, offerId); } } describe('PCTransportManager.negotiate', () => { let originalRTCPeerConnection: unknown; beforeEach(() => { originalRTCPeerConnection = (globalThis as unknown as { RTCPeerConnection?: unknown }) .RTCPeerConnection; (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = StubPC; }); afterEach(() => { (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = originalRTCPeerConnection; }); function makeManager() { const manager = new PCTransportManager('publisher-only', {}, { peerConnectionTimeout: 200 }); const fake = new FakePublisher(); (manager as unknown as { publisher: FakePublisher }).publisher = fake; return { manager, pub: fake }; } it('resolves when an offer past the checkpoint is answered', async () => { const { manager, pub } = makeManager(); const p = manager.negotiate(new AbortController()); const id = pub.startOffer(); pub.answer(id); await expect(p).resolves.toBeUndefined(); }); it('does not resolve on answers for offers at or before the checkpoint', async () => { const { manager, pub } = makeManager(); // Some prior cycle is in flight with id=5 at the moment we capture our // checkpoint. Its answer must NOT satisfy our request — our changes // weren't in offer 5. pub.latestOfferId = 5; const ac = new AbortController(); const p = manager.negotiate(ac); let settled = false; p.then( () => { settled = true; }, () => { settled = true; }, ); pub.answer(5); await flushMicrotasks(); expect(settled).toBe(false); ac.abort(); await expect(p).rejects.toThrow(/aborted/); }); it('resolves through the renegotiate-recursion path', async () => { // Reproduces the field shape: we capture checkpoint=N while an offer N is // in flight. The answer for N arrives (renegotiate=true on the publisher, // so it doesn't satisfy us), then a follow-up offer N+1 is created and // answered. We resolve on the second answer. const { manager, pub } = makeManager(); pub.latestOfferId = 1; const p = manager.negotiate(new AbortController()); pub.answer(1); // does not satisfy checkpoint=1 const id = pub.startOffer(); // 2 pub.answer(id); await expect(p).resolves.toBeUndefined(); }); it('resolves immediately when an answer past the checkpoint already arrived', async () => { const { manager, pub } = makeManager(); pub.latestOfferId = 3; pub.latestAcknowledgedOfferId = 4; await expect(manager.negotiate(new AbortController())).resolves.toBeUndefined(); }); it('resolves concurrent callers independently at their own checkpoints', async () => { const { manager, pub } = makeManager(); // A captures checkpoint=0 const a = manager.negotiate(new AbortController()); // First cycle starts; B captures checkpoint=1 (offer now in flight) const id1 = pub.startOffer(); const b = manager.negotiate(new AbortController()); let bResolved = false; b.then(() => { bResolved = true; }); // The first answer satisfies A (1 > 0) but not B (1 > 1 is false). pub.answer(id1); await a; expect(bResolved).toBe(false); // The next cycle's answer satisfies B. const id2 = pub.startOffer(); pub.answer(id2); await b; expect(bResolved).toBe(true); }); it('rejects when the deadline elapses', async () => { const { manager } = makeManager(); await expect(manager.negotiate(new AbortController())).rejects.toThrow(/timed out/); }); it('rejects when the abort signal fires', async () => { const { manager } = makeManager(); const ac = new AbortController(); const p = manager.negotiate(ac); ac.abort(); await expect(p).rejects.toThrow(/aborted/); }); it('rejects when publisher.negotiate invokes its error callback', async () => { const { manager, pub } = makeManager(); pub.negotiate.mockImplementationOnce(async (onError?: (e: Error) => void) => { onError?.(new Error('publisher boom')); }); await expect(manager.negotiate(new AbortController())).rejects.toThrow(/publisher boom/); }); describe('listener cleanup', () => { it('after success', async () => { const { manager, pub } = makeManager(); const p = manager.negotiate(new AbortController()); const id = pub.startOffer(); pub.answer(id); await p; expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(0); }); it('after non-matching answer (still pending), then abort', async () => { const { manager, pub } = makeManager(); pub.latestOfferId = 5; const ac = new AbortController(); const p = manager.negotiate(ac); pub.answer(5); // does not satisfy checkpoint=5 expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(1); ac.abort(); await expect(p).rejects.toThrow(/aborted/); expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(0); }); it('after deadline', async () => { const { manager, pub } = makeManager(); await expect(manager.negotiate(new AbortController())).rejects.toThrow(/timed out/); expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(0); }); it('after abort', async () => { const { manager, pub } = makeManager(); const ac = new AbortController(); const p = manager.negotiate(ac); ac.abort(); await expect(p).rejects.toThrow(/aborted/); expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(0); }); it('after publisher.negotiate errors', async () => { const { manager, pub } = makeManager(); pub.negotiate.mockImplementationOnce(async (onError?: (e: Error) => void) => { onError?.(new Error('publisher boom')); }); await expect(manager.negotiate(new AbortController())).rejects.toThrow(/publisher boom/); expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(0); }); it('does not leak across many sequential negotiate() calls', async () => { const { manager, pub } = makeManager(); for (let i = 0; i < 12; i += 1) { const p = manager.negotiate(new AbortController()); const id = pub.startOffer(); pub.answer(id); await p; } expect(pub.listenerCount(PCEvents.OfferAnswered)).toBe(0); }); }); // Regression test for publishing call getting stuck // With the old design, NegotiationStarted firing faster than // peerConnectionTimeout kept resetting the timer indefinitely while // NegotiationComplete was suppressed by an unconverging `renegotiate` cycle, // wedging the publishTrack Promise. The offerId-checkpoint design resolves // on the first answer past the checkpoint, regardless of how many cycles // start in between. it('does not hang when many spurious cycles start without converging on the checkpoint', async () => { const { manager, pub } = makeManager(); pub.latestOfferId = 1; // an unrelated cycle is in flight const p = manager.negotiate(new AbortController()); // NegotiationStarted noise (not listened to anymore) interleaved with an // answer for the in-flight offer that doesn't satisfy our checkpoint. pub.emit(PCEvents.NegotiationStarted); pub.emit(PCEvents.NegotiationStarted); pub.answer(1); // doesn't satisfy checkpoint=1 pub.emit(PCEvents.NegotiationStarted); // Eventually a fresh offer is created and answered. const id = pub.startOffer(); // 2 pub.answer(id); await expect(p).resolves.toBeUndefined(); }); }); describe('PCTransportManager.triggerIceRestart', () => { let originalRTCPeerConnection: unknown; beforeEach(() => { originalRTCPeerConnection = (globalThis as unknown as { RTCPeerConnection?: unknown }) .RTCPeerConnection; (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = StubPC; }); afterEach(() => { (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = originalRTCPeerConnection; }); /** * The subscriber must keep applying remote candidates across a reconnect. * * Putting it into `restartingIce` would queue them until a new remote description arrives — * but the server only re-offers the subscriber when the reconnect moved us to another node, * so on an ordinary signal-only resume nothing would ever flush that queue, and the * transport would stop adopting new network paths for the rest of the session. The server * also never sends candidates ahead of the offer that introduces them, so queueing buys * nothing in exchange. */ it('does not stop the subscriber applying remote candidates', async () => { const manager = new PCTransportManager('subscriber-primary', {}); const publisher = new FakePublisher(); (manager as unknown as { publisher: FakePublisher }).publisher = publisher; await manager.triggerIceRestart(); expect(manager.subscriber?.restartingIce).toBe(false); }); }); describe('PCTransportManager.ensurePCTransportConnection', () => { let originalRTCPeerConnection: unknown; beforeEach(() => { originalRTCPeerConnection = (globalThis as unknown as { RTCPeerConnection?: unknown }) .RTCPeerConnection; (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = StubPC; vi.useFakeTimers(); }); afterEach(() => { vi.useRealTimers(); (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = originalRTCPeerConnection; }); /** A manager whose publisher never connects; counts the poll loop's reads of its state. */ function makeConnectingManager() { const manager = new PCTransportManager('publisher-only', {}); (manager as unknown as { publisher: unknown }).publisher = { getConnectionState: () => 'connecting', }; let stateReads = 0; Object.defineProperty(manager, 'state', { get: () => { stateReads += 1; return PCTransportState.CONNECTING; }, }); return { manager, stateReads: () => stateReads }; } it('stops polling once the connection timeout fires', async () => { const { manager, stateReads } = makeConnectingManager(); const wait = manager.ensurePCTransportConnection(undefined, 1_000); const timedOut = expect(wait).rejects.toMatchObject({ reason: ConnectionErrorReason.InternalError, }); await vi.advanceTimersByTimeAsync(1_000); await timedOut; const readsAtTimeout = stateReads(); await vi.advanceTimersByTimeAsync(1_000); expect(stateReads()).toBe(readsAtTimeout); }); it('rejects as cancelled when the abort signal fired before the call', async () => { const { manager } = makeConnectingManager(); const abortController = new AbortController(); abortController.abort(); const wait = manager.ensurePCTransportConnection(abortController, 1_000); const cancelled = expect(wait).rejects.toMatchObject({ reason: ConnectionErrorReason.Cancelled, }); await vi.advanceTimersByTimeAsync(50); await cancelled; }); });