import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import { LogLevel, getWorkerLogLevelListenerCount, setLogLevel, workerLogger } from '../logger'; import { Room } from '../room/Room'; import { ParticipantEvent, RoomEvent } from '../room/events'; import { Track } from '../room/track/Track'; import type { VideoCodec } from '../room/track/options'; import { subscribeToEvents } from '../utils/subscribeToEvents'; import { E2EEManager } from './E2eeManager'; import { BaseKeyProvider } from './KeyProvider'; import { type E2EEManagerCallbacks, EncryptionEvent } from './events'; import type { KeyProviderOptions } from './types'; import { createKeyMaterialFromString } from './utils'; /** * Install just enough of the DOM to let isE2EESupported() return true so * setup() doesn't throw. */ function installE2EEShims() { const w = window as unknown as Record; if (typeof w.RTCRtpSender === 'undefined') { w.RTCRtpSender = class {}; } w.RTCRtpSender.prototype.createEncodedStreams = () => {}; } class FakeWorker { postMessage = vi.fn(); onmessage: ((ev: MessageEvent) => void) | null = null; onerror: unknown = null; levelMessages(): LogLevel[] { return this.postMessage.mock.calls .map(([m]) => m) .filter((m: any) => m?.kind === 'setLogLevel') .map((m: any) => m.data.level); } } function makeManager() { installE2EEShims(); const room = new Room(); const worker = new FakeWorker(); const manager = new E2EEManager( { keyProvider: new BaseKeyProvider({ sharedKey: true }), worker: worker as unknown as Worker }, false, ); return { room, worker, manager }; } describe('E2EEManager log-level listener lifecycle', () => { const startingLevel = workerLogger.getLevel(); const startingCount = getWorkerLogLevelListenerCount(); afterEach(() => { setLogLevel(startingLevel); }); it('forwards level changes to the worker while subscribed', () => { const { room, worker, manager } = makeManager(); manager.setup(room); worker.postMessage.mockClear(); setLogLevel(LogLevel.debug); expect(worker.levelMessages()).toEqual([LogLevel.debug]); manager.dispose(); }); it('dispose() removes the listener and stops forwarding', () => { const { room, worker, manager } = makeManager(); manager.setup(room); manager.dispose(); worker.postMessage.mockClear(); setLogLevel(LogLevel.warn); expect(worker.postMessage).not.toHaveBeenCalled(); expect(getWorkerLogLevelListenerCount()).toBe(startingCount); }); it('re-setup with a new room does not stack listeners', () => { const { worker, manager } = makeManager(); const roomA = new Room(); const roomB = new Room(); manager.setup(roomA); const countAfterFirst = getWorkerLogLevelListenerCount(); manager.setup(roomB); expect(getWorkerLogLevelListenerCount()).toBe(countAfterFirst); worker.postMessage.mockClear(); setLogLevel(LogLevel.debug); expect(worker.levelMessages()).toEqual([LogLevel.debug]); // exactly one delivery manager.dispose(); }); it('dispose() is idempotent', () => { const { room, manager } = makeManager(); manager.setup(room); manager.dispose(); manager.dispose(); expect(getWorkerLogLevelListenerCount()).toBe(startingCount); }); it('dispose() rejects pending encrypt/decrypt futures and clears both maps', async () => { const { room, manager } = makeManager(); manager.setup(room); const encrypting = manager.encryptData(new Uint8Array([1, 2, 3]) as any); const decrypting = manager.handleEncryptedData( new Uint8Array([4, 5, 6]) as any, new Uint8Array([7, 8, 9]) as any, 'peer', 0, ); const priv = manager as unknown as { encryptDataRequests: Map; decryptDataRequests: Map; }; expect(priv.encryptDataRequests.size).toBe(1); expect(priv.decryptDataRequests.size).toBe(1); manager.dispose(); await expect(encrypting).rejects.toThrow(/disposed/); await expect(decrypting).rejects.toThrow(/disposed/); expect(priv.encryptDataRequests.size).toBe(0); expect(priv.decryptDataRequests.size).toBe(0); // Second dispose while maps are empty must not throw. expect(() => manager.dispose()).not.toThrow(); }); }); /** * GC-path test. Flaky by construction — FinalizationRegistry callbacks are * best-effort. Skipped unless vitest is run with `--expose-gc`: * * NODE_OPTIONS="--expose-gc" pnpm exec vitest run src/e2ee/E2eeManager.test.ts * * Deliberately bypasses `manager.setup(room)`. `new Room()` on its own is not * collectable in this test environment (device-change listeners, timers), and * that leak is not what this test is about — it would only mask what we * actually want to verify: that the log-level listener wiring holds nothing * strongly. */ describe('E2EEManager GC cleanup', () => { const startingLevel = workerLogger.getLevel(); beforeEach(() => { installE2EEShims(); }); afterEach(() => { setLogLevel(startingLevel); }); it.skipIf(!(globalThis as any).gc)( 'releases the log-level listener when the manager is garbage collected', async () => { const before = getWorkerLogLevelListenerCount(); // Construct + subscribe in an IIFE so nothing lives on the test's stack. // Direct call to the private subscription — no Room, no leaky graph. const managerRef = ((): WeakRef => { const worker = new FakeWorker(); const manager = new E2EEManager( { keyProvider: new BaseKeyProvider({ sharedKey: true }), worker: worker as unknown as Worker, }, false, ); (manager as unknown as { subscribeToLogLevelChanges(): void }).subscribeToLogLevelChanges(); expect(getWorkerLogLevelListenerCount()).toBe(before + 1); return new WeakRef(manager); })(); // Full major GC + macrotask yield in a loop, with allocation pressure to // force the major sweep FinalizationRegistry needs. // // Crucial: do NOT call `managerRef.deref()` inside the loop. Per spec, // `WeakRef.prototype.deref` keeps the referent alive until the end of the // current job — calling it in the check would pin the manager forever. // Read the listener count (which does not touch the referent) instead. const gc = (globalThis as any).gc as (opts?: { type?: 'major'; execution?: 'sync' }) => void; for (let i = 0; i < 50; i++) { // eslint-disable-next-line no-void void new Array(100_000).fill({ i }); gc({ type: 'major', execution: 'sync' }); await new Promise((r) => setImmediate(r)); if (getWorkerLogLevelListenerCount() === before) break; } // Diagnostic: separate "manager wasn't collected" from "FR didn't fire". expect(managerRef.deref(), 'manager was not collected — strong ref leaked').toBeUndefined(); expect(getWorkerLogLevelListenerCount()).toBe(before); }, ); }); describe('E2EEManager sender codec seeding', () => { function publishVideo(videoCodec: VideoCodec | undefined) { const { room, worker, manager } = makeManager(); room.localParticipant.identity = 'me'; manager.setup(room); const sender = { createEncodedStreams: () => ({ readable: new ReadableStream(), writable: new WritableStream(), }), } as unknown as RTCRtpSender; const track = { isLocal: true, kind: Track.Kind.Video, mediaStreamID: 'ms1', publishOptions: { videoCodec }, }; room.localParticipant.emit(ParticipantEvent.LocalSenderCreated, sender, track as any); manager.dispose(); return worker.postMessage.mock.calls.map(([m]) => m).find((m: any) => m?.kind === 'encode'); } it('seeds the publish codec for h264', () => { expect(publishVideo('h264')?.data.codec).toBe('h264'); }); it('seeds the publish codec for h265', () => { expect(publishVideo('h265')?.data.codec).toBe('h265'); }); it('leaves vp8 unseeded so byte detection still decides', () => { const encode = publishVideo('vp8'); expect(encode).toBeDefined(); expect(encode.data.codec).toBeUndefined(); }); }); describe('E2EEManager local encryption state', () => { it('posts the local state from setLocalParticipantCryptorEnabled', () => { // Create a manager with a worker that records its messages const { room, worker, manager } = makeManager(); manager.setup(room); // Enable encryption for the local participant manager.setLocalParticipantCryptorEnabled(true); // The worker got an enable message that is marked as local expect(worker.postMessage).toHaveBeenCalledWith({ kind: 'enable', data: { enabled: true, participantIdentity: '', local: true }, }); manager.dispose(); }); it('posts the local state from the deprecated setParticipantCryptorEnabled', () => { // Create a manager with a worker that records its messages const { room, worker, manager } = makeManager(); manager.setup(room); // Enable encryption with the deprecated method, which ignores the identity manager.setParticipantCryptorEnabled(true, 'someone-else'); /* <-- DIFFERENCE */ // The worker got an enable message that is marked as local expect(worker.postMessage).toHaveBeenCalledWith({ kind: 'enable', data: { enabled: true, participantIdentity: '', local: true }, }); manager.dispose(); }); it('emits the local status once when the worker confirms the same state twice', async () => { // Create a manager with a worker that records its messages const { room, worker, manager } = makeManager(); manager.setup(room); const managerEvents = subscribeToEvents(manager, [ EncryptionEvent.ParticipantEncryptionStatusChanged, ]); const workerReplies = worker.onmessage as (ev: { data: unknown }) => void; // The worker confirms that local encryption is enabled workerReplies({ data: { kind: 'enable', data: { enabled: true, participantIdentity: '', local: true } }, }); // The manager reports the new status const enabled = await managerEvents.waitFor(EncryptionEvent.ParticipantEncryptionStatusChanged); expect(enabled).toStrictEqual(true); // The worker confirms the same state again, as it does after the room connects workerReplies({ data: { kind: 'enable', data: { enabled: true, participantIdentity: 'me', local: true } }, }); // The manager does not report the status a second time expect( managerEvents.areThereBufferedEvents(EncryptionEvent.ParticipantEncryptionStatusChanged), ).toStrictEqual(false); manager.dispose(); }); }); describe('E2EEManager key posting', () => { class TestKeyProvider extends BaseKeyProvider { async setKey(passphrase: string, keyIndex: number, participantIdentity?: string) { this.onSetEncryptionKey( await createKeyMaterialFromString(passphrase), participantIdentity, keyIndex, ); } } function makeKeyManager(options: Partial) { installE2EEShims(); const room = new Room(); room.localParticipant.identity = 'me'; const worker = new FakeWorker(); const keyProvider = new TestKeyProvider(options); const manager = new E2EEManager({ keyProvider, worker: worker as unknown as Worker }, false); return { room, worker, keyProvider, manager }; } function takePostedKeys(worker: FakeWorker) { const postedKeys = worker.postMessage.mock.calls .map(([m]) => m) .filter((m: any) => m?.kind === 'setKey') .map((m: any) => [m.data.keyIndex, m.data.updateCurrentKeyIndex]); worker.postMessage.mockClear(); return postedKeys; } it.each([{ sharedKey: true }, { sharedKey: false }])( 'does not re-send keys on an enable acknowledgement (sharedKey: $sharedKey)', async (options) => { const { room, worker, keyProvider, manager } = makeKeyManager(options); manager.setup(room); const participantIdentity = options.sharedKey ? undefined : 'me'; await keyProvider.setKey('first', 0, participantIdentity); await keyProvider.setKey('second', 1, participantIdentity); takePostedKeys(worker); worker.onmessage?.( new MessageEvent('message', { data: { kind: 'enable', data: { enabled: true, participantIdentity: 'me', local: true } }, }), ); expect(takePostedKeys(worker)).toEqual([]); manager.dispose(); }, ); it('posts the keys set before setup on the first SignalConnected only', async () => { const { room, worker, keyProvider, manager } = makeKeyManager({ sharedKey: true }); await keyProvider.setKey('first', 0); await keyProvider.setKey('second', 1); manager.setup(room); takePostedKeys(worker); room.emit(RoomEvent.SignalConnected); expect(takePostedKeys(worker)).toEqual([ [0, false], [1, true], ]); room.emit(RoomEvent.SignalConnected); expect(takePostedKeys(worker)).toEqual([]); manager.dispose(); }); it('does not re-send on SignalConnected the keys set after setup', async () => { const { room, worker, keyProvider, manager } = makeKeyManager({ sharedKey: true }); await keyProvider.setKey('first', 0); manager.setup(room); await keyProvider.setKey('second', 1); expect(takePostedKeys(worker)).toEqual([[1, true]]); room.emit(RoomEvent.SignalConnected); expect(takePostedKeys(worker)).toEqual([[0, false]]); manager.dispose(); }); });