@stream-io/video-client 2.0.0-beta.0 → 2.0.0-beta.1

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

@@ -0,0 +1,242 @@
+/**
+ * @vitest-environment happy-dom
+ */
+
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Call } from '../Call';
+import { CallingState } from '../store';
+import { StreamClient } from '../coordinator/connection/client';
+import { ClientEventReporter } from '../reporting';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { ClientState } from '../store';
+
+/**
+ * The core's whole part in the React Native ringing lifecycle: await RN's
+ * preparation inside the join, tell RN when a ringing join failed terminally or
+ * the call ended, and stop a join that a `leave()` overtook. What preparation
+ * and release actually do is RN's, and is tested there.
+ */
+
+const createCall = (ringing: boolean) => {
+  const streamClient = new StreamClient('abc');
+  return new Call({
+    type: 'test',
+    id: generateUUIDv4(),
+    ringing,
+    streamClient,
+    clientEventReporter: new ClientEventReporter({
+      streamClient,
+      enabled: false,
+    }),
+    clientState: new ClientState(),
+  });
+};
+
+const install = (overrides: Record<string, unknown> = {}) => {
+  const beforeJoin = vi.fn(() => Promise.resolve());
+  const onJoinFailed = vi.fn(() => Promise.resolve());
+  const onLeave = vi.fn();
+  const callingX = { joinCall: vi.fn(), endCall: vi.fn() };
+  globalThis.streamRNVideoSDK = {
+    ringingCallLifecycle: { beforeJoin, onJoinFailed, onLeave },
+    callingX,
+    // `leave()` reaches this unconditionally; the globals object is all-or-nothing
+    callManager: { setup: vi.fn(), start: vi.fn(), stop: vi.fn() },
+    ...overrides,
+  } as any;
+  return { beforeJoin, onJoinFailed, onLeave, callingX };
+};
+
+describe('ringing call lifecycle integration', () => {
+  beforeEach(() => {
+    globalThis.streamRNVideoSDK = undefined;
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      headers: { get: () => 'AMS1-P2' },
+    } as Response);
+  });
+
+  afterEach(() => {
+    globalThis.streamRNVideoSDK = undefined;
+    vi.restoreAllMocks();
+  });
+
+  it('prepares a ringing call before it joins', async () => {
+    const { beforeJoin, callingX } = install();
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await call.join();
+
+    expect(beforeJoin).toHaveBeenCalledTimes(1);
+    expect(beforeJoin).toHaveBeenCalledBefore(callingX.joinCall);
+    expect(doJoin).toHaveBeenCalledTimes(1);
+  });
+
+  it('leaves ordinary calls to join themselves', async () => {
+    const { beforeJoin, onJoinFailed } = install();
+    const call = createCall(false);
+    vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await call.join();
+
+    expect(beforeJoin).not.toHaveBeenCalled();
+    expect(onJoinFailed).not.toHaveBeenCalled();
+  });
+
+  it('does not join when preparation fails, and reports the failure', async () => {
+    const { beforeJoin, onJoinFailed } = install();
+    beforeJoin.mockRejectedValue(new Error('no key'));
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await expect(call.join()).rejects.toThrow('no key');
+
+    expect(doJoin).not.toHaveBeenCalled();
+    expect(onJoinFailed).toHaveBeenCalledWith(call);
+  });
+
+  it('reports a terminal join failure, keeping the original error', async () => {
+    const { onJoinFailed } = install();
+    const call = createCall(true);
+    vi.spyOn(call as any, 'doJoin').mockRejectedValue(new Error('sfu down'));
+
+    await expect(call.join({ maxJoinRetries: 1 })).rejects.toThrow('sfu down');
+
+    expect(onJoinFailed).toHaveBeenCalledWith(call);
+  });
+
+  it('refuses a duplicate join on a live call without tearing it down', async () => {
+    const { beforeJoin, onJoinFailed, onLeave } = install();
+    const call = createCall(true);
+    vi.spyOn(call as any, 'doJoin').mockImplementation(async () => {
+      call.state.setCallingState(CallingState.JOINED);
+    });
+
+    await call.join();
+    await expect(call.join()).rejects.toThrow('Illegal State');
+
+    expect(beforeJoin).toHaveBeenCalledTimes(1);
+    // the guard sits ahead of the failure boundary, so nothing is released
+    expect(onJoinFailed).not.toHaveBeenCalled();
+    expect(onLeave).not.toHaveBeenCalled();
+  });
+
+  it('tells the owner when a ringing call ends', async () => {
+    const { onLeave } = install();
+    const call = createCall(true);
+
+    await call.leave();
+
+    expect(onLeave).toHaveBeenCalledWith(call);
+    expect(call.state.callingState).toBe(CallingState.LEFT);
+  });
+
+  it('does not tell the owner about an ordinary call', async () => {
+    const { onLeave } = install();
+
+    await createCall(false).leave();
+
+    expect(onLeave).not.toHaveBeenCalled();
+  });
+
+  it('keeps an app-owned manager across leave, as setE2EEManager promises', async () => {
+    install();
+    const call = createCall(true);
+    const manager = { encrypt: vi.fn(), decrypt: vi.fn() } as any;
+    call.setE2EEManager(manager);
+
+    await call.leave();
+
+    expect(call.e2eeManager).toBe(manager);
+  });
+
+  it('abandons a join that a leave overtook during native registration', async () => {
+    let finishRegistration: () => void = () => {};
+    const { callingX, onLeave, onJoinFailed } = install();
+    callingX.joinCall.mockImplementation(
+      () => new Promise<void>((resolve) => (finishRegistration = resolve)),
+    );
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    const joining = call.join();
+    await vi.waitFor(() => expect(callingX.joinCall).toHaveBeenCalled());
+    await call.leave({ reject: false });
+    finishRegistration();
+
+    // A superseding leave is not a join failure: the join settles quietly rather
+    // than rejecting, and the error path stays shut.
+    await expect(joining).resolves.toBeUndefined();
+    expect(onJoinFailed).not.toHaveBeenCalled();
+    expect(callingX.endCall).not.toHaveBeenCalledWith(call, 'error');
+    // Release still happens - `leave()` itself fires it, which is why the join
+    // does not need to.
+    expect(onLeave).toHaveBeenCalledTimes(1);
+    // `doJoin` captures the generation itself, so this check has to be here
+    expect(doJoin).not.toHaveBeenCalled();
+  });
+
+  it('does not resume the retry loop after a leave during backoff', async () => {
+    vi.useFakeTimers();
+    try {
+      install();
+      const call = createCall(true);
+      const doJoin = vi
+        .spyOn(call as any, 'doJoin')
+        .mockRejectedValue(new Error('recoverable'));
+
+      const joining = call.join().catch(() => {});
+      await vi.waitFor(() => expect(doJoin).toHaveBeenCalledTimes(1));
+      await call.leave({ reject: false });
+      await vi.advanceTimersByTimeAsync(30_000);
+      await joining;
+
+      expect(doJoin).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('prepares an outgoing call that this join makes ringing', async () => {
+    const { beforeJoin } = install();
+    // a fresh instance, not ringing until its first join says so
+    const call = createCall(false);
+    vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await call.join({ ring: true });
+
+    // reading `call.ringing` before applying `options.ring` would skip
+    // preparation entirely on this path
+    expect(beforeJoin).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops a join that a leave overtook during preparation', async () => {
+    let releaseHook: () => void = () => {};
+    const { beforeJoin, onLeave, onJoinFailed } = install();
+    beforeJoin.mockImplementation(
+      () => new Promise<void>((resolve) => (releaseHook = resolve)),
+    );
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    const joining = call.join();
+    await vi.waitFor(() => expect(beforeJoin).toHaveBeenCalled());
+    await call.leave({ reject: false });
+    releaseHook();
+
+    await expect(joining).resolves.toBeUndefined();
+    expect(onJoinFailed).not.toHaveBeenCalled();
+    // Whatever `beforeJoin` installed is released exactly once, by the `leave()`
+    // that overtook the join rather than by the join itself.
+    expect(onLeave).toHaveBeenCalledTimes(1);
+    expect(doJoin).not.toHaveBeenCalled();
+    expect(call.state.callingState).toBe(CallingState.LEFT);
+  });
+
+  it('is inert when no React Native globals are registered', async () => {
+    const call = createCall(true);
+    await expect(call.leave()).resolves.not.toThrow();
+  });
+});

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.disconnect.test.ts

@@ -0,0 +1,62 @@
+import '../rtc/__tests__/mocks/webrtc.mocks';
+import { describe, expect, it, vi } from 'vitest';
+import { StreamVideoClient } from '../StreamVideoClient';
+import { CallingState } from '../store';
+
+const fakeCall = (cid: string, callingState: CallingState) => ({
+  cid,
+  state: { callingState },
+  leave: vi.fn().mockResolvedValue(undefined),
+  watching: false,
+});
+
+describe('disconnectUser leaves calls', () => {
+  it('leaves non-LEFT calls, before closing the connection', async () => {
+    const client = new StreamVideoClient('abc');
+    const order: string[] = [];
+
+    const active = fakeCall('default:active', CallingState.JOINED);
+    const left = fakeCall('default:left', CallingState.LEFT);
+    active.leave.mockImplementation(async () => {
+      order.push('leave:active');
+    });
+    left.leave.mockImplementation(async () => {
+      order.push('leave:left');
+    });
+
+    client.state.setCalls([active, left] as never);
+
+    // @ts-expect-error faking the minimum the guard needs
+    client.streamClient.user = { id: 'jane' };
+    vi.spyOn(client.streamClient, 'disconnectUser').mockImplementation(
+      async () => {
+        order.push('ws:close');
+      },
+    );
+
+    await client.disconnectUser();
+
+    expect(active.leave).toHaveBeenCalledWith({
+      message: 'client.disconnectUser() called',
+    });
+    expect(left.leave).not.toHaveBeenCalled();
+    expect(order).toEqual(['leave:active', 'ws:close']);
+    expect(client.state.connectedUser).toBeUndefined();
+  });
+
+  it('a failing leave does not block the disconnect', async () => {
+    const client = new StreamVideoClient('abc');
+    const boom = fakeCall('default:boom', CallingState.JOINED);
+    boom.leave.mockRejectedValue(new Error('nope'));
+    client.state.setCalls([boom] as never);
+
+    // @ts-expect-error faking the minimum the guard needs
+    client.streamClient.user = { id: 'jane' };
+    vi.spyOn(client.streamClient, 'disconnectUser').mockResolvedValue(
+      undefined as never,
+    );
+
+    await expect(client.disconnectUser()).resolves.toBeUndefined();
+    expect(boom.leave).toHaveBeenCalled();
+  });
+});

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/devices/__tests__/CameraManager.test.ts

@@ -1,7 +1,7 @@
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { ClientEventReporter } from '../../reporting';
-import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { CallingState, ClientState } from '../../store';
 
 import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
 import { fromPartial } from '@total-typescript/shoehorn';
@@ -89,7 +89,7 @@ describe('CameraManager', () => {
       type: '',
       streamClient,
       clientEventReporter: new ClientEventReporter({ streamClient }),
-      clientStore: new StreamVideoWriteableStateStore(),
+      clientState: new ClientState(),
     });
     manager = new CameraManager(call, devicePersistence);
   });

package/src/devices/__tests__/DeviceManager.test.ts

@@ -2,7 +2,7 @@
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { ClientEventReporter } from '../../reporting';
-import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { CallingState, ClientState } from '../../store';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
@@ -99,7 +99,7 @@ describe('Device Manager', () => {
         type: '',
         streamClient,
         clientEventReporter: new ClientEventReporter({ streamClient }),
-        clientStore: new StreamVideoWriteableStateStore(),
+        clientState: new ClientState(),
       }),
       { enabled: false, storageKey },
     );

package/src/devices/__tests__/DeviceManagerFilters.test.ts

@@ -3,7 +3,7 @@ import { of } from 'rxjs';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { ClientEventReporter } from '../../reporting';
-import { StreamVideoWriteableStateStore } from '../../store';
+import { ClientState } from '../../store';
 import { DeviceManagerState } from '../DeviceManagerState';
 import { DeviceManager } from '../DeviceManager';
 import {
@@ -53,7 +53,7 @@ describe('MediaStream Filters', () => {
         type: '',
         streamClient,
         clientEventReporter: new ClientEventReporter({ streamClient }),
-        clientStore: new StreamVideoWriteableStateStore(),
+        clientState: new ClientState(),
       }),
     );
   });

package/src/devices/__tests__/MicrophoneManager.test.ts

@@ -12,7 +12,7 @@ import {
   AudioBitrateProfile,
   TrackType,
 } from '../../gen/video/sfu/models/models';
-import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { CallingState, ClientState } from '../../store';
 import {
   createLocalStorageMock,
   emitDeviceIds,
@@ -105,7 +105,7 @@ describe('MicrophoneManager', () => {
       type: '',
       streamClient,
       clientEventReporter: new ClientEventReporter({ streamClient }),
-      clientStore: new StreamVideoWriteableStateStore(),
+      clientState: new ClientState(),
     });
     const devicePersistence = { enabled: false, storageKey: '' };
     manager = new MicrophoneManager(call, devicePersistence, 'disable-tracks');

package/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { MicrophoneManager } from '../MicrophoneManager';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
-import { StreamVideoWriteableStateStore } from '../../store';
+import { ClientState } from '../../store';
 import {
   mockAudioDevices,
   mockAudioStream,
@@ -91,7 +91,7 @@ describe('MicrophoneManager React Native', () => {
         id: '',
         type: '',
         streamClient,
-        clientStore: new StreamVideoWriteableStateStore(),
+        clientState: new ClientState(),
         clientEventReporter: new ClientEventReporter({ streamClient }),
       }),
       devicePersistence,

package/src/devices/__tests__/ScreenShareManager.test.ts

@@ -3,7 +3,7 @@ import { ScreenShareManager } from '../ScreenShareManager';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { ClientEventReporter } from '../../reporting';
-import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { CallingState, ClientState } from '../../store';
 import * as RxUtils from '../../store/rxUtils';
 import { mockCall, mockDeviceIds$, mockScreenShareStream } from './mocks';
 import { getScreenShareStream } from '../devices';
@@ -44,7 +44,7 @@ describe('ScreenShareManager', () => {
         type: '',
         streamClient,
         clientEventReporter: new ClientEventReporter({ streamClient }),
-        clientStore: new StreamVideoWriteableStateStore(),
+        clientState: new ClientState(),
       }),
     );
   });
@@ -99,7 +99,7 @@ describe('ScreenShareManager', () => {
 
   it('should use call settings to set up constraints', async () => {
     const call = manager['call'];
-    call.state.setCurrentValue(call.state['settingsSubject'], {
+    RxUtils.setCurrentValue(call.state['settingsSubject'], {
       // @ts-expect-error partial data
       screensharing: {
         target_resolution: {

package/src/devices/__tests__/SpeakerManager.test.ts

@@ -17,7 +17,7 @@ import { checkIfAudioOutputChangeSupported } from '../devices';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { ClientEventReporter } from '../../reporting';
-import { StreamVideoWriteableStateStore } from '../../store';
+import { ClientState } from '../../store';
 import { defaultDeviceId } from '../devicePersistence';
 
 vi.mock('../devices.ts', () => {
@@ -55,7 +55,7 @@ describe('SpeakerManager.test', () => {
         type: '',
         streamClient,
         clientEventReporter: new ClientEventReporter({ streamClient }),
-        clientStore: new StreamVideoWriteableStateStore(),
+        clientState: new ClientState(),
       }),
       devicePersistence,
     );
@@ -162,7 +162,7 @@ describe('SpeakerManager.test', () => {
         type: '',
         streamClient,
         clientEventReporter: new ClientEventReporter({ streamClient }),
-        clientStore: new StreamVideoWriteableStateStore(),
+        clientState: new ClientState(),
       }),
       { enabled: true, storageKey },
     );
@@ -190,7 +190,7 @@ describe('SpeakerManager.test', () => {
           type: '',
           streamClient,
           clientEventReporter: new ClientEventReporter({ streamClient }),
-          clientStore: new StreamVideoWriteableStateStore(),
+          clientState: new ClientState(),
         }),
         { enabled: true, storageKey },
       );