@stream-io/video-client 1.48.0 → 1.50.0

package/src/__tests__/Call.lifecycle.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @vitest-environment happy-dom
+ */
+
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Call } from '../Call';
+import { StreamClient } from '../coordinator/connection/client';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { StreamVideoWriteableStateStore } from '../store';
+
+describe('Call lifecycle wiring', () => {
+  let call: Call;
+
+  beforeEach(() => {
+    call = new Call({
+      type: 'test',
+      id: generateUUIDv4(),
+      streamClient: new StreamClient('abc'),
+      clientStore: new StreamVideoWriteableStateStore(),
+    });
+  });
+
+  // Regression guard for the Call-owned helper teardown chain. Each of
+  // these helpers holds a resource (timer, listener, AudioContext) that
+  // leaks across calls if teardown is dropped during a refactor.
+  // Covers trackSubscriptionManager, audioBindingsWatchdog, and
+  // dynascaleManager. SFU-lifecycle disposables (publisher/subscriber/
+  // sfuStatsReporter) require a real join and are out of scope.
+  it('call.leave() tears down all Call-owned helpers exactly once', async () => {
+    const trackSubDispose = vi.spyOn(call.trackSubscriptionManager, 'dispose');
+    const audioBindingsDispose = vi.spyOn(
+      call.audioBindingsWatchdog!,
+      'dispose',
+    );
+    const dynascaleDispose = vi.spyOn(call.dynascaleManager!, 'dispose');
+
+    await call.leave();
+
+    expect(trackSubDispose).toHaveBeenCalledTimes(1);
+    expect(audioBindingsDispose).toHaveBeenCalledTimes(1);
+    expect(dynascaleDispose).toHaveBeenCalledTimes(1);
+  });
+
+  // Order matters: the SFU subscription pump must finish tearing down
+  // before DynascaleManager closes its AudioContext, otherwise helpers
+  // can run on a closed context (logged as warnings or thrown by
+  // happy-dom). This is the contract the leave() teardown chain encodes.
+  it('call.leave() tears down helpers in the documented order', async () => {
+    const trackSubDispose = vi.spyOn(call.trackSubscriptionManager, 'dispose');
+    const audioBindingsDispose = vi.spyOn(
+      call.audioBindingsWatchdog!,
+      'dispose',
+    );
+    const dynascaleDispose = vi.spyOn(call.dynascaleManager!, 'dispose');
+
+    await call.leave();
+
+    const trackSubOrder = trackSubDispose.mock.invocationCallOrder[0];
+    const audioBindingsOrder = audioBindingsDispose.mock.invocationCallOrder[0];
+    const dynascaleOrder = dynascaleDispose.mock.invocationCallOrder[0];
+
+    expect(trackSubOrder).toBeLessThan(audioBindingsOrder);
+    expect(audioBindingsOrder).toBeLessThan(dynascaleOrder);
+  });
+});

package/src/__tests__/Call.publishing.test.ts

@@ -290,6 +290,109 @@ describe('Publishing and Unpublishing tracks', () => {
       expect(participant!.screenShareStream).toBeUndefined();
       expect(participant!.screenShareAudioStream).toBeUndefined();
     });
+
+    it('does not throw if sfuClient is cleared while the mute-state RPC is in flight', async () => {
+      let releaseMuteUpdate!: () => void;
+      let signalMuteUpdateEntered!: () => void;
+      const muteUpdateEntered = new Promise<void>(
+        (resolve) => (signalMuteUpdateEntered = resolve),
+      );
+      sfuClient.updateMuteStates = vi.fn().mockImplementation(() => {
+        signalMuteUpdateEntered();
+        return new Promise<void>((resolve) => (releaseMuteUpdate = resolve));
+      });
+
+      const track = new MediaStreamTrack() as MediaStreamAudioTrack;
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getAudioTracks').mockReturnValue([track]);
+
+      const inflight = call.publish(mediaStream, TrackType.AUDIO);
+
+      await muteUpdateEntered;
+
+      call['sfuClient'] = undefined;
+      releaseMuteUpdate();
+
+      await inflight;
+    });
+
+    it('updates local stream state when sfuClient is replaced with the same session id', async () => {
+      let releaseMuteUpdate!: () => void;
+      let signalMuteUpdateEntered!: () => void;
+      const muteUpdateEntered = new Promise<void>(
+        (resolve) => (signalMuteUpdateEntered = resolve),
+      );
+      sfuClient.updateMuteStates = vi.fn().mockImplementation(() => {
+        signalMuteUpdateEntered();
+        return new Promise<void>((resolve) => (releaseMuteUpdate = resolve));
+      });
+
+      const track = new MediaStreamTrack() as MediaStreamAudioTrack;
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getAudioTracks').mockReturnValue([track]);
+
+      const inflight = call.publish(mediaStream, TrackType.AUDIO);
+
+      await muteUpdateEntered;
+
+      const replacementSfuClient = vi.fn() as unknown as StreamSfuClient;
+      // @ts-expect-error sessionId is readonly
+      replacementSfuClient['sessionId'] = sessionId;
+      replacementSfuClient.updateMuteStates = vi.fn();
+      call['sfuClient'] = replacementSfuClient;
+      releaseMuteUpdate();
+
+      await inflight;
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant?.publishedTracks).toEqual([TrackType.AUDIO]);
+      expect(participant?.audioStream).toBe(mediaStream);
+    });
+
+    it('skips local stream state update when sfuClient is replaced with a new session id', async () => {
+      let releaseMuteUpdate!: () => void;
+      let signalMuteUpdateEntered!: () => void;
+      const muteUpdateEntered = new Promise<void>(
+        (resolve) => (signalMuteUpdateEntered = resolve),
+      );
+      sfuClient.updateMuteStates = vi.fn().mockImplementation(() => {
+        signalMuteUpdateEntered();
+        return new Promise<void>((resolve) => (releaseMuteUpdate = resolve));
+      });
+
+      const track = new MediaStreamTrack() as MediaStreamAudioTrack;
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getAudioTracks').mockReturnValue([track]);
+
+      const inflight = call.publish(mediaStream, TrackType.AUDIO);
+
+      await muteUpdateEntered;
+
+      const replacementSessionId = 'replacement-session-id';
+      // @ts-expect-error partial data
+      call.state.updateOrAddParticipant(replacementSessionId, {
+        sessionId: replacementSessionId,
+        publishedTracks: [],
+      });
+
+      const replacementSfuClient = vi.fn() as unknown as StreamSfuClient;
+      // @ts-expect-error sessionId is readonly
+      replacementSfuClient['sessionId'] = replacementSessionId;
+      replacementSfuClient.updateMuteStates = vi.fn();
+      call['sfuClient'] = replacementSfuClient;
+      releaseMuteUpdate();
+
+      await inflight;
+
+      const originalParticipant =
+        call.state.findParticipantBySessionId(sessionId);
+      const replacementParticipant =
+        call.state.findParticipantBySessionId(replacementSessionId);
+      expect(originalParticipant?.publishedTracks).toEqual([]);
+      expect(originalParticipant?.audioStream).toBeUndefined();
+      expect(replacementParticipant?.publishedTracks).toEqual([]);
+      expect(replacementParticipant?.audioStream).toBeUndefined();
+    });
   });
 
   describe('Deprecated methods', () => {

package/src/__tests__/StreamSfuClient.test.ts

@@ -0,0 +1,275 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StreamSfuClient } from '../StreamSfuClient';
+import { Dispatcher } from '../rtc';
+import { StreamClient } from '../coordinator/connection/client';
+
+/**
+ * Minimal `WebSocket` stub used to drive `StreamSfuClient.close()` while the
+ * underlying connection is still in `CONNECTING` state. The constructor
+ * leaves `readyState = CONNECTING`; `close()` records the call and flips
+ * to `CLOSED` so subsequent assertions can see what happened.
+ */
+class CapturingWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  static instances: CapturingWebSocket[] = [];
+
+  readyState = CapturingWebSocket.CONNECTING;
+  url: string;
+  binaryType = 'blob';
+  closeArgs: { code?: number; reason?: string } | undefined;
+  private listeners = new Map<string, Set<(e: unknown) => void>>();
+
+  constructor(url: string | URL) {
+    this.url = typeof url === 'string' ? url : url.toString();
+    CapturingWebSocket.instances.push(this);
+  }
+
+  addEventListener(event: string, listener: (e: unknown) => void) {
+    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+    this.listeners.get(event)!.add(listener);
+  }
+  removeEventListener(event: string, listener: (e: unknown) => void) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  close(code?: number, reason?: string) {
+    this.closeArgs = { code, reason };
+    this.readyState = CapturingWebSocket.CLOSED;
+  }
+}
+
+const buildSfuClient = () => {
+  const dispatcher = new Dispatcher();
+  const streamClient = new StreamClient('test-key');
+  return new StreamSfuClient({
+    dispatcher,
+    sessionId: 'session-id-test',
+    streamClient,
+    cid: 'default:test',
+    credentials: {
+      server: {
+        url: 'https://test.invalid',
+        ws_endpoint: 'wss://test.invalid/ws',
+        edge_name: 'sfu-test',
+      },
+      token: 'token',
+      ice_servers: [],
+    },
+    tag: 'test',
+    enableTracing: false,
+  });
+};
+
+describe('StreamSfuClient.close()', () => {
+  beforeEach(() => {
+    CapturingWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', CapturingWebSocket);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+  });
+
+  it('closes the WebSocket even when it is still in CONNECTING state', () => {
+    const sfuClient = buildSfuClient();
+    const ws = CapturingWebSocket.instances.at(-1)!;
+    expect(ws.readyState).toBe(CapturingWebSocket.CONNECTING);
+
+    sfuClient.close(1000, 'tearing down');
+
+    expect(ws.closeArgs).toBeDefined();
+    expect(ws.closeArgs?.code).toBe(1000);
+    expect(ws.readyState).toBe(CapturingWebSocket.CLOSED);
+  });
+
+  it('rejects a pending joinResponseTask on close so awaiters do not hang', async () => {
+    const sfuClient = buildSfuClient();
+    const joinTask = sfuClient.joinTask;
+
+    sfuClient.close(1000, 'aborting');
+
+    await expect(joinTask).rejects.toThrow(/SFU client disposed/);
+  });
+
+  it('does not blow up when the WebSocket is already CLOSED', () => {
+    const sfuClient = buildSfuClient();
+    const ws = CapturingWebSocket.instances.at(-1)!;
+    ws.readyState = CapturingWebSocket.CLOSED;
+
+    expect(() => sfuClient.close(1000, 'noop')).not.toThrow();
+    // close() should not be called twice
+    expect(ws.closeArgs).toBeUndefined();
+  });
+
+  it('leaveAndClose returns within ~grace period when the SFU is silent (no hang)', async () => {
+    const sfuClient = buildSfuClient();
+    vi.spyOn(
+      sfuClient as unknown as {
+        notifyLeave: (reason: string) => Promise<void>;
+      },
+      'notifyLeave',
+    ).mockResolvedValue(undefined);
+
+    // joinResponseTask stays pending forever — verify leaveAndClose still returns.
+    const start = Date.now();
+    await Promise.race([
+      sfuClient.leaveAndClose('silent-sfu'),
+      new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error('leaveAndClose hung past 2x grace')),
+          StreamSfuClient.LEAVE_NOTIFY_GRACE_MS * 2,
+        ),
+      ),
+    ]);
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeLessThan(StreamSfuClient.LEAVE_NOTIFY_GRACE_MS * 2);
+  });
+
+  it('close() does NOT produce an unhandled rejection when nobody awaits joinTask', async () => {
+    // Capture unhandledrejection events that fire during this test. Without
+    // the safe-catch attached to `joinResponseTask.promise`, dispose-time
+    // reject would surface here.
+    const unhandled: PromiseRejectionEvent[] = [];
+    const onUnhandled = (e: PromiseRejectionEvent) => {
+      unhandled.push(e);
+      // mark as handled so it doesn't crash the test runner
+      e.preventDefault?.();
+    };
+    if (typeof window !== 'undefined') {
+      window.addEventListener('unhandledrejection', onUnhandled);
+    }
+    // Node-side fallback so the test passes regardless of test environment.
+    const onProcessUnhandled = (reason: unknown) => {
+      unhandled.push({ reason } as unknown as PromiseRejectionEvent);
+    };
+    process.on('unhandledRejection', onProcessUnhandled);
+
+    try {
+      const sfuClient = buildSfuClient();
+      // Intentionally do NOT touch joinTask anywhere — no .catch, no await.
+      sfuClient.close(1000, 'aborting before any join');
+
+      // give microtasks + a tick for any unhandledrejection event to fire
+      await new Promise((r) => setTimeout(r, 50));
+      expect(unhandled).toHaveLength(0);
+    } finally {
+      if (typeof window !== 'undefined') {
+        window.removeEventListener('unhandledrejection', onUnhandled);
+      }
+      process.off('unhandledRejection', onProcessUnhandled);
+    }
+  });
+});
+
+describe('StreamSfuClient.leaveAndClose()', () => {
+  beforeEach(() => {
+    CapturingWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', CapturingWebSocket);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+  });
+
+  type JoinResponseTaskHandle = {
+    joinResponseTask: {
+      resolve: (v: unknown) => void;
+      reject: (err: unknown) => void;
+    };
+  };
+
+  it('notifies the SFU when joinResponseTask is already resolved', async () => {
+    const sfuClient = buildSfuClient();
+    (sfuClient as unknown as JoinResponseTaskHandle).joinResponseTask.resolve(
+      {},
+    );
+    const notifyLeaveSpy = vi
+      .spyOn(
+        sfuClient as unknown as {
+          notifyLeave: (reason: string) => Promise<void>;
+        },
+        'notifyLeave',
+      )
+      .mockResolvedValue(undefined);
+
+    await sfuClient.leaveAndClose('user-leaving');
+
+    expect(notifyLeaveSpy).toHaveBeenCalledWith('user-leaving');
+  });
+
+  it('waits for an in-flight join and notifies the SFU when it resolves within the grace period', async () => {
+    const sfuClient = buildSfuClient();
+    const notifyLeaveSpy = vi
+      .spyOn(
+        sfuClient as unknown as {
+          notifyLeave: (reason: string) => Promise<void>;
+        },
+        'notifyLeave',
+      )
+      .mockResolvedValue(undefined);
+
+    vi.useFakeTimers();
+    const leavePromise = sfuClient.leaveAndClose('user-leaving');
+
+    // simulate the SFU sending JoinResponse 50 ms in (well within the grace window)
+    await vi.advanceTimersByTimeAsync(50);
+    (sfuClient as unknown as JoinResponseTaskHandle).joinResponseTask.resolve(
+      {},
+    );
+    // flush remaining timers (the losing race branch and any microtasks)
+    await vi.runAllTimersAsync();
+    await leavePromise;
+
+    expect(notifyLeaveSpy).toHaveBeenCalledWith('user-leaving');
+  });
+
+  it('skips notifyLeave when the join does not complete within the grace period', async () => {
+    const sfuClient = buildSfuClient();
+    const notifyLeaveSpy = vi
+      .spyOn(
+        sfuClient as unknown as {
+          notifyLeave: (reason: string) => Promise<void>;
+        },
+        'notifyLeave',
+      )
+      .mockResolvedValue(undefined);
+
+    vi.useFakeTimers();
+    const leavePromise = sfuClient.leaveAndClose('silent-sfu');
+    // run past the grace window — the task is never resolved
+    await vi.advanceTimersByTimeAsync(
+      StreamSfuClient.LEAVE_NOTIFY_GRACE_MS + 50,
+    );
+    await leavePromise;
+
+    expect(notifyLeaveSpy).not.toHaveBeenCalled();
+  });
+
+  it('skips notifyLeave when joinResponseTask rejects within the grace period', async () => {
+    const sfuClient = buildSfuClient();
+    const notifyLeaveSpy = vi
+      .spyOn(
+        sfuClient as unknown as {
+          notifyLeave: (reason: string) => Promise<void>;
+        },
+        'notifyLeave',
+      )
+      .mockResolvedValue(undefined);
+
+    vi.useFakeTimers();
+    const leavePromise = sfuClient.leaveAndClose('rejected');
+    await vi.advanceTimersByTimeAsync(20);
+    (sfuClient as unknown as JoinResponseTaskHandle).joinResponseTask.reject(
+      new Error('SFU went away'),
+    );
+    await vi.runAllTimersAsync();
+    await leavePromise;
+
+    expect(notifyLeaveSpy).not.toHaveBeenCalled();
+  });
+});