@stream-io/video-client 1.59.0 → 1.60.0

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

@@ -0,0 +1,71 @@
+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 { CallingState, StreamVideoWriteableStateStore } from '../store';
+import { CallSessionResponse } from '../gen/coordinator';
+
+const ME = 'jane';
+
+// `resolveOwnRingOutcome` owns the decision and is tested on its own. This
+// covers the effect around it: that it runs for a ringing call and that the
+// `ringing` guard keeps it off every other call.
+describe('Leaving a call settled by the current user', () => {
+  let call: Call;
+
+  const createCall = async (ringing: boolean) => {
+    const clientStore = new StreamVideoWriteableStateStore();
+    const streamClient = new StreamClient('abc');
+    call = new Call({
+      type: 'test',
+      id: generateUUIDv4(),
+      streamClient,
+      clientEventReporter: new ClientEventReporter({ streamClient }),
+      clientStore,
+      ringing,
+    });
+
+    clientStore.setConnectedUser(fromPartial({ id: ME }));
+    vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+    await call.setup();
+    return call;
+  };
+
+  const settleByMe = () =>
+    call.state['sessionSubject'].next(
+      fromPartial<CallSessionResponse>({
+        id: 'session-1',
+        accepted_by: {},
+        rejected_by: { [ME]: new Date().toISOString() },
+        missed_by: {},
+        participants: [],
+        participants_count_by_role: {},
+      }),
+    );
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('leaves a ringing call the current user rejected', async () => {
+    await createCall(true);
+    expect(call.state.callingState).toBe(CallingState.RINGING);
+
+    settleByMe();
+
+    expect(call.leave).toHaveBeenCalled();
+  });
+
+  it('ignores the same session on a call that is not ringing', async () => {
+    await createCall(false);
+    expect(call.state.callingState).toBe(CallingState.IDLE);
+
+    settleByMe();
+
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/StreamSfuClient.test.ts

@@ -3,6 +3,8 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { Dispatcher } from '../rtc';
 import { StreamClient } from '../coordinator/connection/client';
 import { getTimers } from '../timers';
+import { getSdkInfo, setSdkInfo } from '../helpers/client-details';
+import { SdkType } from '../gen/video/sfu/models/models';
 
 /**
  * Minimal `WebSocket` stub used to drive `StreamSfuClient.close()` while the
@@ -431,3 +433,49 @@ describe('StreamSfuClient.leaveAndClose()', () => {
     expect(notifyLeaveSpy).not.toHaveBeenCalled();
   });
 });
+
+describe('StreamSfuClient RPC headers', () => {
+  beforeEach(() => {
+    CapturingWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', CapturingWebSocket);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('identifies the SDK and its version in every RPC request', async () => {
+    const sdkInfo = getSdkInfo();
+    setSdkInfo({
+      type: SdkType.REACT,
+      major: '1',
+      minor: '2',
+      patch: '3',
+    });
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValue(
+        new Response('{}', { headers: { 'content-type': 'application/json' } }),
+      );
+    vi.stubGlobal('fetch', fetchMock);
+
+    try {
+      const sfuClient = buildSfuClient();
+      (
+        sfuClient as unknown as {
+          joinResponseTask: { resolve: (v: unknown) => void };
+        }
+      ).joinResponseTask.resolve({});
+
+      await sfuClient.startNoiseCancellation();
+
+      const [, init] = fetchMock.mock.calls[0];
+      expect(new Headers(init.headers).get('x-stream-client')).toBe(
+        'stream-video-react-v1.2.3',
+      );
+    } finally {
+      setSdkInfo(sdkInfo!);
+    }
+  });
+});

package/src/__tests__/StreamVideoClient.ringing.test.ts

@@ -17,7 +17,14 @@ const secret = process.env.STREAM_SECRET!;
 
 describe('StreamVideoClient Ringing', () => {
   const serverClient = new StreamClient(apiKey, secret);
-  const testUserIds = ['oliver', 'sacha', 'marcelo'];
+
+  // user ids are generated per test: CI runs share a single Stream app, so
+  // fixed ids let a concurrently running job ring these users and satisfy the
+  // assertions in this file with an unrelated call.
+  let oliverId: string;
+  let sachaId: string;
+  let marceloId: string;
+  let testUserIds: string[];
 
   let oliverClient: StreamVideoClient;
   let sachaClient: StreamVideoClient;
@@ -54,6 +61,11 @@ describe('StreamVideoClient Ringing', () => {
   };
 
   beforeEach(async () => {
+    const suffix = crypto.randomUUID();
+    oliverId = `oliver-${suffix}`;
+    sachaId = `sacha-${suffix}`;
+    marceloId = `marcelo-${suffix}`;
+    testUserIds = [oliverId, sachaId, marceloId];
     [oliverClient, sachaClient, marceloClient] =
       await createClients(testUserIds);
   });
@@ -75,11 +87,11 @@ describe('StreamVideoClient Ringing', () => {
       await call.create({
         ring: true,
         data: {
-          created_by_id: 'oliver',
+          created_by_id: oliverId,
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -112,9 +124,9 @@ describe('StreamVideoClient Ringing', () => {
         ring: true,
         data: {
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -144,9 +156,9 @@ describe('StreamVideoClient Ringing', () => {
         ring: false, // don't ring all members by default
         data: {
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -162,7 +174,7 @@ describe('StreamVideoClient Ringing', () => {
       // oliver is calling sacha. only sacha should get a ring event
       const sachaIndividualRing = expectEvent(sachaClient, 'call.ring');
       const marceloIndividualRing = expectEvent(marceloClient, 'call.ring');
-      await oliverCall.ring({ members_ids: ['sacha'] });
+      await oliverCall.ring({ members_ids: [sachaId] });
       await expect(sachaIndividualRing).resolves.toHaveProperty(
         'call.cid',
         oliverCall.cid,
@@ -175,7 +187,7 @@ describe('StreamVideoClient Ringing', () => {
       // sacha is calling marcelo. only marcelo should get a ring event
       const oliverIndividualRing = expectEvent(oliverClient, 'call.ring');
       const marceloIndividualRing2 = expectEvent(marceloClient, 'call.ring');
-      await sachaCall.ring({ members_ids: ['marcelo'] });
+      await sachaCall.ring({ members_ids: [marceloId] });
       await expect(marceloIndividualRing2).resolves.toHaveProperty(
         'call.cid',
         sachaCall.cid,
@@ -241,8 +253,8 @@ describe('StreamVideoClient Ringing', () => {
       const serverCall = serverClient.video.call('default', callId);
       await serverCall.create({
         data: {
-          created_by_id: 'oliver',
-          members: [{ user_id: 'oliver' }, { user_id: 'sacha' }],
+          created_by_id: oliverId,
+          members: [{ user_id: oliverId }, { user_id: sachaId }],
         },
       });
 
@@ -266,7 +278,7 @@ describe('StreamVideoClient Ringing', () => {
       await oliverCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'oliver' }, { user_id: 'sacha' }],
+          members: [{ user_id: oliverId }, { user_id: sachaId }],
         },
       });
 
@@ -302,7 +314,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'oliver' }],
+          members: [{ user_id: marceloId }, { user_id: oliverId }],
         },
       });
 
@@ -332,7 +344,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'sacha' }],
+          members: [{ user_id: marceloId }, { user_id: sachaId }],
         },
       });
 
@@ -354,7 +366,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'oliver' }],
+          members: [{ user_id: marceloId }, { user_id: oliverId }],
         },
       });
 
@@ -375,7 +387,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'sacha' }],
+          members: [{ user_id: marceloId }, { user_id: sachaId }],
         },
       });
 

package/src/coordinator/connection/__tests__/eventListenerIsolation.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StreamClient } from '../client';
+import { StableWSConnection } from '../connection';
+import { videoLoggerSystem } from '../../../logger';
+import type { StreamVideoEvent } from '../types';
+
+const event: StreamVideoEvent = { type: 'network.changed', online: true };
+
+describe('event listener isolation', () => {
+  let client: StreamClient;
+  let sink: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    sink = vi.fn();
+    videoLoggerSystem.configureLoggers({
+      coordinator: { sink, level: 'error' },
+    });
+    client = new StreamClient('key');
+  });
+
+  afterEach(() => {
+    videoLoggerSystem.restoreDefaults();
+    vi.restoreAllMocks();
+  });
+
+  const errorLogs = () =>
+    sink.mock.calls.filter(([level]) => level === 'error');
+
+  it('keeps dispatching after a listener throws', () => {
+    const failure = new Error('listener blew up');
+    const first = vi.fn(() => {
+      throw failure;
+    });
+    const second = vi.fn();
+
+    client.on('network.changed', first);
+    client.on('network.changed', second);
+
+    expect(() => client.dispatchEvent(event)).not.toThrow();
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(second).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports a synchronous throw through the logger', () => {
+    const failure = new Error('listener blew up');
+    client.on('network.changed', () => {
+      throw failure;
+    });
+
+    client.dispatchEvent(event);
+
+    expect(errorLogs()).toEqual([
+      [
+        'error',
+        '[coordinator]: Unhandled error in event listener',
+        failure,
+        event,
+      ],
+    ]);
+  });
+
+  it('reports a rejection from an async listener', async () => {
+    const failure = new Error('async listener blew up');
+    client.on('network.changed', async () => {
+      throw failure;
+    });
+    const next = vi.fn();
+    client.on('network.changed', next);
+
+    client.dispatchEvent(event);
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(errorLogs()).toHaveLength(0);
+
+    await vi.waitFor(() => expect(errorLogs()).toHaveLength(1));
+    expect(errorLogs()[0]).toEqual([
+      'error',
+      '[coordinator]: Unhandled error in event listener',
+      failure,
+      event,
+    ]);
+  });
+
+  it('isolates a faulty `all` listener from type specific listeners', () => {
+    const all = vi.fn(() => {
+      throw new Error('all listener blew up');
+    });
+    const typed = vi.fn();
+
+    client.on('all', all);
+    client.on('network.changed', typed);
+
+    client.dispatchEvent(event);
+
+    expect(all).toHaveBeenCalledTimes(1);
+    expect(typed).toHaveBeenCalledTimes(1);
+    expect(errorLogs()).toHaveLength(1);
+  });
+
+  it('schedules the connection check even when a listener throws', () => {
+    const connection = new StableWSConnection(client);
+    const scheduleConnectionCheck = vi
+      .spyOn(connection, 'scheduleConnectionCheck')
+      .mockImplementation(() => {});
+
+    client.on('all', () => {
+      throw new Error('listener blew up');
+    });
+
+    connection.onmessage(connection.wsID, {
+      data: JSON.stringify({ type: 'custom' }),
+    } as MessageEvent);
+
+    expect(scheduleConnectionCheck).toHaveBeenCalledTimes(1);
+  });
+});

package/src/coordinator/connection/client.ts

@@ -10,6 +10,7 @@ import { TokenManager } from './token_manager';
 import {
   addConnectionEventListeners,
   generateUUIDv4,
+  invokeEventListener,
   isErrorResponse,
   KnownCodes,
   removeConnectionEventListeners,
@@ -589,12 +590,12 @@ export class StreamClient {
 
     // call generic listeners
     for (const listener of this.listeners.all || []) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
 
     // call type specific listeners
     for (const listener of this.listeners[event.type] || []) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
   };
 

package/src/coordinator/connection/types.ts

@@ -200,6 +200,18 @@ export type Logger = (
   ...args: unknown[]
 ) => void;
 
+export type RingStatePollingOptions = {
+  /**
+   * Quiet time after the ring starts, before the first poll. Defaults to 15_000.
+   */
+  startAfterMs?: number;
+
+  /**
+   * The interval between polls. Defaults to 5_000.
+   */
+  intervalMs?: number;
+};
+
 export type StreamClientOptions = Partial<AxiosRequestConfig> & {
   /**
    * Used to disable warnings that are triggered by using connectUser or connectAnonymousUser server-side.
@@ -305,6 +317,13 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    */
   rejectCallWhenBusy?: boolean;
 
+  /**
+   * Caller-side polling for the ring outcome, used when the `call.accepted`,
+   * `call.rejected` or `call.missed` event never arrives. Enabled by default;
+   * set to `false` to disable, or pass an object to tune the timings.
+   */
+  ringStatePolling?: false | RingStatePollingOptions;
+
   /**
    * Device persistence preference options (web only).
    */

package/src/coordinator/connection/utils.ts

@@ -1,6 +1,7 @@
 import type { AxiosResponse } from 'axios';
 import type { APIErrorResponse } from './types';
 import type { ConnectionErrorEvent } from '../../gen/coordinator';
+import type { ScopedLogger } from '../../logger';
 
 export const sleep = (m: number) => new Promise((r) => setTimeout(r, m));
 
@@ -118,3 +119,30 @@ export function isCloseEvent(
 ): res is CloseEvent {
   return (res as CloseEvent).code !== undefined;
 }
+
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener
+ * cannot abort the dispatch loop nor the bookkeeping that follows it.
+ *
+ * @param listener the listener to invoke.
+ * @param event the event to pass to the listener.
+ * @param logger the logger to report listener failures with.
+ */
+export const invokeEventListener = <T>(
+  listener: (event: T) => unknown,
+  event: T,
+  logger: ScopedLogger,
+) => {
+  try {
+    const result = listener(event);
+    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
+      Promise.resolve(result).catch((error) => report(logger, error, event));
+    }
+  } catch (error) {
+    report(logger, error, event);
+  }
+};
+
+const report = (logger: ScopedLogger, error: unknown, event: unknown) => {
+  logger.error('Unhandled error in event listener', error, event);
+};