@stream-io/video-client 1.59.1 → 1.61.0

package/src/StreamSfuClient.ts

@@ -39,7 +39,8 @@ import {
 } from './helpers/promise';
 import { withoutConcurrency } from './helpers/concurrency';
 import { getTimers } from './timers';
-import { Tracer, TraceSlice } from './stats';
+import { getSdkInfo } from './helpers/client-details';
+import { getStreamClientId, Tracer, TraceSlice } from './stats';
 import { SfuJoinError, SfuTimeoutError } from './errors';
 
 export type StreamSfuClientConstructor = {
@@ -271,7 +272,10 @@ export class StreamSfuClient {
     this.rpc = createSignalClient({
       baseUrl: server.url,
       interceptors: [
-        withHeaders({ Authorization: `Bearer ${token}` }),
+        withHeaders({
+          Authorization: `Bearer ${token}`,
+          'X-Stream-Client': getStreamClientId(getSdkInfo()),
+        }),
         this.tracer && withRequestTracer(this.tracer.trace),
         this.logger.getLogLevel() === 'trace' && withRequestLogger(this.logger),
         withTimeout(rpcRequestTimeout, this.tracer?.trace),

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

@@ -1,104 +1,156 @@
 import '../rtc/__tests__/mocks/webrtc.mocks';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
 import { Call } from '../Call';
 import { StreamClient } from '../coordinator/connection/client';
 import { ClientEventReporter } from '../reporting';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import { CallingState, StreamVideoWriteableStateStore } from '../store';
+import { CallSettingsResponse } from '../gen/coordinator';
 
+const TIMEOUT_MS = 30_000;
+
+// The timeout's own behaviour is covered by `ringing/__tests__/RingTimeout`.
+// This file covers the wiring: that a ringing call arms one and that leaving
+// cancels it.
 describe('Auto drop ringing calls', () => {
-  let call: Call;
   const userId = 'jane';
+  let call: Call;
 
-  beforeEach(async () => {
-    vi.useFakeTimers();
-
+  const ringingCall = () => {
     const clientStore = new StreamVideoWriteableStateStore();
     const streamClient = new StreamClient('abc');
-    call = new Call({
+    const newCall = new Call({
       type: 'test',
       id: generateUUIDv4(),
       streamClient,
       clientEventReporter: new ClientEventReporter({ streamClient }),
-      clientStore: clientStore,
+      clientStore,
+      ringing: true,
     });
 
-    // @ts-expect-error mocking only what we need for the test
-    clientStore.connectedUserSubject.next({
-      id: userId,
-    });
-
-    call.state['callingStateSubject'].next(CallingState.RINGING);
-
-    vi.spyOn(call, 'leave').mockImplementation(async () => {
-      console.log(`TEST: leave() called`);
-    });
-  });
-
-  it('caller should drop ringing calls after a timeout if no one accepted', async () => {
-    call.state['settingsSubject'].next({
-      // @ts-expect-error mocking only what we need for the test, we use fake timers, so undefined for timeout works
-      ring: {},
-      // @ts-expect-error mocking only what we need for the test
-      screensharing: {
-        enabled: false,
-        target_resolution: {
-          width: 100,
-          height: 100,
+    clientStore.setConnectedUser(fromPartial({ id: userId }));
+    newCall.state['createdBySubject'].next(fromPartial({ id: userId }));
+    newCall.state['settingsSubject'].next(
+      fromPartial<CallSettingsResponse>({
+        ring: {
+          auto_cancel_timeout_ms: TIMEOUT_MS,
+          incoming_call_timeout_ms: TIMEOUT_MS,
+          missed_call_timeout_ms: TIMEOUT_MS,
         },
-      },
-    });
+        screensharing: {
+          enabled: false,
+          target_resolution: { width: 100, height: 100 },
+        },
+      }),
+    );
+    newCall.state['sessionSubject'].next(
+      fromPartial({
+        id: 'session-1',
+        accepted_by: {},
+        rejected_by: {},
+        missed_by: {},
+      }),
+    );
+    newCall.state['callingStateSubject'].next(CallingState.RINGING);
+
+    vi.spyOn(newCall, 'leave').mockResolvedValue(undefined);
+    return newCall;
+  };
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    call = ringingCall();
+  });
 
-    // @ts-expect-error mocking only what we need for the test
-    call.state['createdBySubject'].next({
-      id: userId,
-    });
+  afterEach(() => {
+    call['cancelAutoDrop']();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
 
-    // black-box test, calling private method
-    call['scheduleAutoDrop']();
+  it('is armed when a call starts ringing', async () => {
+    call.state['callingStateSubject'].next(CallingState.IDLE);
 
-    await vi.runAllTimersAsync();
+    call['handleRingingCall']();
 
+    expect(call['ringTimeout']).toBeDefined();
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
     expect(call.leave).toHaveBeenCalledWith({
       reject: true,
       reason: 'timeout',
-      message: `ringing timeout - no one accepted`,
+      message: 'ringing timeout - no one accepted',
     });
   });
 
-  it(`callee should drop ringing calls after a timeout if user didn't interact with incoming call screen`, async () => {
-    call.state['settingsSubject'].next({
-      // @ts-expect-error mocking only what we need for the test, we use fake timers, so undefined for timeout works
-      ring: {},
-      // @ts-expect-error mocking only what we need for the test
-      screensharing: {
-        enabled: false,
-        target_resolution: {
-          width: 100,
-          height: 100,
-        },
-      },
-    });
+  it('is cancelled by cancelAutoDrop', async () => {
+    call['scheduleAutoDrop']();
 
-    // @ts-expect-error mocking only what we need for the test
-    call.state['createdBySubject'].next({
-      id: 'not-' + userId,
-    });
+    call['cancelAutoDrop']();
 
-    // black-box test, calling private method
+    expect(call['ringTimeout']).toBeUndefined();
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  // the calling state stays RINGING well into teardown, so the watchdogs have
+  // to be paused before `leave` awaits anything
+  it('pauses the watchdogs synchronously when leave starts', async () => {
     call['scheduleAutoDrop']();
+    call['scheduleRingStatePolling']();
+    const timeout = call['ringTimeout'];
+    vi.spyOn(call, 'leave').mockRestore();
+    vi.spyOn(call, 'reject').mockResolvedValue(fromPartial({}));
 
-    await vi.runAllTimersAsync();
+    const poller = call['ringStatePoller'];
 
-    expect(call.leave).toHaveBeenCalledWith({
-      reject: true,
-      reason: 'timeout',
-      message: `ringing timeout - user didn't interact with incoming call screen`,
-    });
+    const leaving = call.leave({ reject: false });
+
+    // paused, not cancelled: both keep the window this leave is ending
+    expect(call['ringTimeout']).toBe(timeout);
+    expect(call['ringStatePoller']).toBe(poller);
+    expect(timeout!['timeoutId']).toBeUndefined();
+    expect(timeout!['stopped']).toBe(false);
+    expect(poller!['idleTimeoutId']).toBeUndefined();
+    expect(poller!['stopped']).toBe(false);
+
+    await leaving.catch(() => {});
+
+    expect(timeout!['stopped']).toBe(true);
+    expect(poller!['stopped']).toBe(true);
   });
 
-  afterEach(() => {
-    vi.useRealTimers();
+  it('restores both watchdogs when rejecting the ring fails', async () => {
+    call['scheduleAutoDrop']();
+    call['scheduleRingStatePolling']();
+    const timeout = call['ringTimeout'];
+    const deadlineAt = timeout!['deadlineAt'];
+    const poller = call['ringStatePoller'];
+    const pollDeadlineAt = poller!['deadlineAt'];
+    vi.spyOn(call, 'leave').mockRestore();
+    vi.spyOn(call, 'reject').mockRejectedValueOnce(new Error('transient'));
+
+    await expect(call.leave({ reject: true })).rejects.toThrow('transient');
+
+    expect(call.state.callingState).toBe(CallingState.RINGING);
+    expect(call['ringTimeout']).toBe(timeout);
+    expect(timeout!['timeoutId']).toBeDefined();
+    expect(timeout!['deadlineAt']).toBe(deadlineAt);
+    expect(call['ringStatePoller']).toBe(poller);
+    expect(poller!['deadlineAt']).toBe(pollDeadlineAt);
+    expect(poller!['stopped']).toBe(false);
+  });
+
+  it('replaces a previously armed timeout', async () => {
+    call['scheduleAutoDrop']();
+    const first = call['ringTimeout'];
+
+    call['scheduleAutoDrop']();
+
+    expect(call['ringTimeout']).not.toBe(first);
+    expect(first!['stopped']).toBe(true);
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -0,0 +1,87 @@
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
+import { Call } from '../Call';
+import { StreamClient } from '../coordinator/connection/client';
+import { ClientEventReporter } from '../reporting';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { StreamVideoWriteableStateStore } from '../store';
+import { CallSessionResponse } from '../gen/coordinator';
+
+describe('Call.getRingState', () => {
+  const callId = generateUUIDv4();
+
+  const fakeCall = (sessionId?: string) => {
+    const streamClient = new StreamClient('abc');
+    const call = new Call({
+      type: 'test',
+      id: callId,
+      streamClient,
+      clientEventReporter: new ClientEventReporter({ streamClient }),
+      clientStore: new StreamVideoWriteableStateStore(),
+    });
+
+    if (sessionId) {
+      call.state['sessionSubject'].next(
+        fromPartial<CallSessionResponse>({ id: sessionId }),
+      );
+    }
+
+    const get = vi
+      .spyOn(streamClient, 'get')
+      .mockResolvedValue(fromPartial({ session_id: sessionId }));
+
+    return { call, get };
+  };
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('reads the ring state of the current session', async () => {
+    const { call, get } = fakeCall('session-1');
+
+    await call.getRingState();
+
+    expect(get).toHaveBeenCalledWith(`/call/test/${callId}/ring_state`, {
+      call_session_id: 'session-1',
+    });
+  });
+
+  it('reads the ring state of an explicitly named session', async () => {
+    // ending a call clears its current session, so a caller reconciling after
+    // `call.ended` has to name the session it rang on
+    const { call, get } = fakeCall('current-session');
+
+    await call.getRingState('ended-session');
+
+    expect(get).toHaveBeenCalledWith(`/call/test/${callId}/ring_state`, {
+      call_session_id: 'ended-session',
+    });
+  });
+
+  it('returns the coordinator response', async () => {
+    const { call, get } = fakeCall('session-1');
+    get.mockResolvedValue(
+      fromPartial({
+        session_id: 'session-1',
+        accepted_by: { bob: '2026-08-24T10:00:04Z' },
+      }),
+    );
+
+    await expect(call.getRingState()).resolves.toMatchObject({
+      session_id: 'session-1',
+      accepted_by: { bob: '2026-08-24T10:00:04Z' },
+    });
+  });
+
+  it('rejects when the call has no session to read', async () => {
+    const { call, get } = fakeCall();
+
+    await expect(call.getRingState()).rejects.toThrow(
+      'Cannot read the ring state: the call has no session',
+    );
+    expect(get).not.toHaveBeenCalled();
+  });
+});