livekit-client 2.22.3 → 2.23.0

package/src/room/Room.test.ts

@@ -10,6 +10,7 @@ import {
 } from '@livekit/protocol';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import MockMediaStreamTrack from '../test/MockMediaStreamTrack';
+import { stubMissingDeflateRawSupport } from '../test/compressionStreamStubs';
 import Room, { ConnectionState } from './Room';
 import { roomConnectOptionDefaults, roomOptionDefaults } from './defaults';
 import { EngineEvent, ParticipantEvent, RoomEvent } from './events';
@@ -46,8 +47,8 @@ describe('Active device switch', () => {
 });
 
 describe('Room signaling options', () => {
-  it('advertises packet trailer capability when E2EE can handle trailers', async () => {
-    const room = new Room();
+  /** Drives `connectSignal` with E2EE enabled against a stub engine, returning the `join` mock. */
+  async function connectSignalWithE2EE(room: Room) {
     const join = vi.fn().mockResolvedValue({
       joinResponse: new JoinResponse({
         room: { name: 'test-room', sid: 'room-sid' },
@@ -91,19 +92,44 @@ describe('Room signaling options', () => {
       new AbortController(),
     );
 
+    return join;
+  }
+
+  function expectCapabilities(
+    join: ReturnType<typeof vi.fn>,
+    clientInfoCapabilities: Array<ClientInfo_Capability>,
+  ) {
     expect(join).toHaveBeenCalledWith(
       'wss://test.livekit.io',
       'test-token',
       expect.objectContaining({
-        clientInfoCapabilities: [
-          ClientInfo_Capability.CAP_PACKET_TRAILER,
-          ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW,
-        ],
+        clientInfoCapabilities,
         e2eeEnabled: true,
       }),
       expect.any(AbortSignal),
       false,
     );
+  }
+
+  it('advertises packet trailer capability when E2EE can handle trailers', async () => {
+    const join = await connectSignalWithE2EE(new Room());
+
+    expectCapabilities(join, [
+      ClientInfo_Capability.CAP_PACKET_TRAILER,
+      ClientInfo_Capability.CAP_COMPRESSION_DEFLATE_RAW,
+    ]);
+  });
+
+  it('does not advertise deflate-raw compression when the runtime cannot decompress it', async () => {
+    const restoreCompressionStreams = stubMissingDeflateRawSupport();
+    try {
+      const join = await connectSignalWithE2EE(new Room());
+
+      // Otherwise peers would compress what they send us and we'd have to drop it.
+      expectCapabilities(join, [ClientInfo_Capability.CAP_PACKET_TRAILER]);
+    } finally {
+      restoreCompressionStreams();
+    }
   });
 });
 
@@ -321,3 +347,119 @@ describe('stream state updates', () => {
     expect(participantEvents).not.toHaveBeenCalled();
   });
 });
+
+describe('audio context ownership', () => {
+  class StubAudioContext {
+    state: AudioContextState = 'running';
+
+    closed = false;
+
+    async close() {
+      this.closed = true;
+      this.state = 'closed';
+    }
+
+    async resume() {
+      this.state = 'running';
+    }
+  }
+
+  const created: StubAudioContext[] = [];
+
+  function stubAudioContext() {
+    created.length = 0;
+    vi.stubGlobal(
+      'AudioContext',
+      class extends StubAudioContext {
+        constructor() {
+          super();
+          created.push(this);
+        }
+      },
+    );
+  }
+
+  /** `acquireAudioContext` and `releaseAudioContext` are private */
+  function internals(room: Room) {
+    return room as unknown as {
+      acquireAudioContext: () => Promise<void>;
+      releaseAudioContext: (retained?: unknown[]) => Promise<void>;
+      audioContext?: StubAudioContext;
+      ownsAudioContext: boolean;
+      localParticipant: { setAudioContext: (ctx: AudioContext | undefined) => Promise<void> };
+    };
+  }
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('closes a context it created for a webAudioMix object that supplies none', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+
+    await room.acquireAudioContext();
+    expect(created).toHaveLength(1);
+    expect(room.ownsAudioContext).toBe(true);
+    expect(room.audioContext).toBe(created[0]);
+
+    await room.releaseAudioContext();
+    expect(created[0].closed).toBe(true);
+    expect(room.audioContext).toBeUndefined();
+  });
+
+  it('leaves a supplied context open', async () => {
+    stubAudioContext();
+    const provided = new StubAudioContext();
+    const room = internals(
+      new Room({ webAudioMix: { audioContext: provided as unknown as AudioContext } }),
+    );
+
+    await room.acquireAudioContext();
+    expect(room.ownsAudioContext).toBe(false);
+    expect(created).toHaveLength(0);
+
+    await room.releaseAudioContext();
+    expect(provided.closed).toBe(false);
+  });
+
+  it('closes the context even when a retained track fails to detach', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+    await room.acquireAudioContext();
+
+    const retained = { setAudioContext: () => Promise.reject(new Error('detach failed')) };
+    await room.releaseAudioContext([retained]);
+
+    expect(created[0].closed).toBe(true);
+  });
+
+  it('does not build a context for an acquire queued behind a release', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+    await room.acquireAudioContext();
+    expect(created).toHaveLength(1);
+
+    // `startAudio` reads `audioContextReleased` before it waits on the mutex, so its acquire can
+    // already be queued behind a disconnect by the time the flag is set
+    const released = room.releaseAudioContext();
+    const acquired = room.acquireAudioContext();
+    await Promise.all([released, acquired]);
+
+    expect(created).toHaveLength(1);
+    expect(created[0].closed).toBe(true);
+    expect(room.audioContext).toBeUndefined();
+  });
+
+  it('closes the outgoing context even when a participant fails to move off it', async () => {
+    stubAudioContext();
+    const room = internals(new Room({ webAudioMix: {} }));
+    await room.acquireAudioContext();
+
+    vi.spyOn(room.localParticipant, 'setAudioContext').mockRejectedValue(new Error('move failed'));
+    await room.releaseAudioContext();
+
+    expect(created[0].closed).toBe(true);
+  });
+});