@stream-io/video-client 1.59.1 → 1.61.0

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 { StreamVideoWriteableStateStore } 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,
+    }),
+    clientStore: new StreamVideoWriteableStateStore(),
+  });
+};
+
+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/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/events/__tests__/call.test.ts

@@ -1,16 +1,8 @@
 import { describe, expect, it, vi } from 'vitest';
-import { fromPartial } from '@total-typescript/shoehorn';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { watchCallEnded, watchSfuCallEnded } from '../call';
 import {
-  watchCallAccepted,
-  watchCallEnded,
-  watchCallRejected,
-  watchSfuCallEnded,
-} from '../call';
-import {
-  CallAcceptedEvent,
   CallEndedEvent,
-  CallResponse,
   OwnCapability,
   RejectCallResponse,
 } from '../../gen/coordinator';
@@ -20,189 +12,7 @@ import { ClientEventReporter } from '../../reporting';
 import { SfuEvent } from '../../gen/video/sfu/event/events';
 import { CallEndedReason } from '../../gen/video/sfu/models/models';
 
-describe('Call ringing events', () => {
-  describe(`call.accepted`, () => {
-    it(`will ignore events from the current user`, async () => {
-      const call = fakeCall();
-      vi.spyOn(call, 'join');
-      const handler = watchCallAccepted(call);
-      const event: CallAcceptedEvent = {
-        type: 'call.accepted',
-        // @ts-expect-error incomplete data
-        user: { id: 'test-user-id' },
-      };
-      await handler(event);
-
-      expect(call.join).not.toHaveBeenCalled();
-    });
-
-    it(`will join the call for the caller if atleast one callee has accepted`, async () => {
-      const call = fakeCall({ currentUserId: 'test-user' });
-      vi.spyOn(call, 'join').mockImplementation(async () => {
-        console.log(`TEST: join() called`);
-      });
-      const handler = watchCallAccepted(call);
-      const event: CallAcceptedEvent = {
-        type: 'call.accepted',
-        // @ts-expect-error incomplete data
-        user: { id: 'test-user-id-callee' },
-        // @ts-expect-error incomplete data
-        call: { created_by: { id: 'test-user' } },
-      };
-      await handler(event);
-
-      expect(call.join).toHaveBeenCalled();
-    });
-  });
-
-  it('will not join the call for the other callee automatically when someone accepts', async () => {
-    const call = fakeCall({ currentUserId: 'test-user-id-callee-2' });
-    vi.spyOn(call, 'join').mockImplementation(async () => {
-      console.log(`TEST: join() called`);
-    });
-    const handler = watchCallAccepted(call);
-    const event: CallAcceptedEvent = {
-      type: 'call.accepted',
-      // @ts-expect-error incomplete data
-      user: { id: 'test-user-id-callee-1' },
-      // @ts-expect-error incomplete data
-      call: { created_by: { id: 'test-user-id-caller' } },
-    };
-
-    await handler(event);
-
-    expect(call.join).not.toHaveBeenCalled();
-  });
-
-  describe(`call.rejected`, () => {
-    it(`caller will leave the call if all callees have rejected`, async () => {
-      const call = fakeCall({ currentUserId: 'm1' });
-      call.state.updateFromCallResponse({
-        ...fakeMetadata(),
-        // @ts-expect-error type issue
-        created_by: { id: 'm1' },
-      });
-      call.state.setMembers([
-        // @ts-expect-error incomplete data
-        { user_id: 'm1' },
-        // @ts-expect-error incomplete data
-        { user_id: 'm2' },
-        // @ts-expect-error incomplete data
-        { user_id: 'm3' },
-      ]);
-      call.state.setCallingState(CallingState.RINGING);
-      vi.spyOn(call, 'leave').mockImplementation(async () => {
-        console.log(`TEST: leave() called`);
-      });
-
-      const handler = watchCallRejected(call);
-      // all members reject the call
-      await handler({
-        type: 'call.rejected',
-        // @ts-expect-error type issue
-        user: {
-          id: 'm2',
-        },
-        call: {
-          // @ts-expect-error type issue
-          created_by: {
-            id: 'm1',
-          },
-          // @ts-expect-error type issue
-          session: {
-            rejected_by: {
-              m2: new Date().toISOString(),
-              m3: new Date().toISOString(),
-            },
-          },
-        },
-      });
-      expect(call.leave).toHaveBeenCalledWith({
-        reject: true,
-        reason: 'cancel',
-        message: 'ring: everyone rejected',
-      });
-    });
-
-    it(`caller will not leave the call if only one callee rejects`, async () => {
-      const call = fakeCall();
-      call.state.updateFromCallResponse({
-        ...fakeMetadata(),
-        // @ts-expect-error type issue
-        created_by: { id: 'm0' },
-      });
-      // @ts-expect-error incomplete data
-      call.state.setMembers([{ user_id: 'm1' }, { user_id: 'm2' }]);
-      vi.spyOn(call, 'leave').mockImplementation(async () => {
-        console.log(`TEST: leave() called`);
-      });
-      const handler = watchCallRejected(call);
-
-      // only one member rejects the call
-      const event: CallAcceptedEvent = {
-        type: 'call.rejected',
-        // @ts-expect-error type issue
-        user: {
-          id: 'm2',
-        },
-        call: {
-          // @ts-expect-error type issue
-          created_by: {
-            id: 'm0',
-          },
-          // @ts-expect-error type issue
-          session: {
-            rejected_by: {
-              m2: new Date().toISOString(),
-            },
-          },
-        },
-      };
-      await handler(event);
-
-      expect(call.leave).not.toHaveBeenCalled();
-    });
-
-    it('callee will leave the call if caller rejects', async () => {
-      const call = fakeCall({ currentUserId: 'm1' });
-      call.state.updateFromCallResponse({
-        ...fakeMetadata(),
-        // @ts-expect-error type issue
-        created_by: { id: 'm0' },
-      });
-      // @ts-expect-error incomplete data
-      call.state.setMembers([{ user_id: 'm1' }, { user_id: 'm2' }]);
-      vi.spyOn(call, 'leave').mockImplementation(async () => {
-        console.log(`TEST: leave() called`);
-      });
-      const handler = watchCallRejected(call);
-
-      // only one member rejects the call
-      const event: CallAcceptedEvent = {
-        type: 'call.rejected',
-        // @ts-expect-error type issue
-        user: {
-          id: 'm0',
-        },
-        call: {
-          // @ts-expect-error type issue
-          created_by: {
-            id: 'm0',
-          },
-          // @ts-expect-error type issue
-          session: {
-            rejected_by: {
-              m0: new Date().toISOString(),
-            },
-          },
-        },
-      };
-      await handler(event);
-
-      expect(call.leave).toHaveBeenCalled();
-    });
-  });
-
+describe('Call lifecycle events', () => {
   describe(`call.ended`, () => {
     it(`will leave the call unless joined`, async () => {
       const call = fakeCall();
@@ -377,28 +187,3 @@ const fakeCall = ({ ring = true, currentUserId = 'test-user-id' } = {}) => {
     ringing: ring,
   });
 };
-
-const fakeMetadata = (): CallResponse => {
-  return fromPartial({
-    id: '12345',
-    type: 'development',
-    cid: 'development:12345',
-
-    created_by: {
-      id: 'test-user-id',
-    },
-    blocked_user_ids: [],
-    egress: {},
-
-    settings: {
-      ring: {
-        auto_cancel_timeout_ms: 30000,
-        incoming_call_timeout_ms: 30000,
-        missed_call_timeout_ms: 30000,
-      },
-      screensharing: {
-        target_resolution: undefined,
-      },
-    },
-  });
-};

package/src/events/call.ts

@@ -1,81 +1,9 @@
 import { CallingState } from '../store';
 import { Call } from '../Call';
-import {
-  CallAcceptedEvent,
-  CallRejectedEvent,
-  OwnCapability,
-} from '../gen/coordinator';
+import { OwnCapability } from '../gen/coordinator';
 import { CallEnded } from '../gen/video/sfu/event/events';
 import { CallEndedReason } from '../gen/video/sfu/models/models';
 
-/**
- * Event handler that watched the delivery of `call.accepted`.
- * Once the event is received, the call is joined.
- */
-export const watchCallAccepted = (call: Call) => {
-  return async function onCallAccepted(event: CallAcceptedEvent) {
-    // We want to discard the event if it's from the current user
-    if (event.user.id === call.currentUserId) return;
-    const { state } = call;
-    if (
-      event.call.created_by.id === call.currentUserId &&
-      state.callingState === CallingState.RINGING
-    ) {
-      await call.join();
-    }
-  };
-};
-
-/**
- * Event handler that watches delivery of `call.rejected` Websocket event.
- * Once the event is received, the call is left.
- */
-export const watchCallRejected = (call: Call) => {
-  return async function onCallRejected(event: CallRejectedEvent) {
-    // We want to discard the event if it's from the current user
-    if (event.user.id === call.currentUserId) return;
-    const { call: eventCall } = event;
-    const { session: callSession } = eventCall;
-
-    if (!callSession) {
-      call.logger.warn(
-        'No call session provided. Ignoring call.rejected event.',
-        event,
-      );
-      return;
-    }
-
-    const rejectedBy = callSession.rejected_by;
-    const { members, callingState } = call.state;
-    if (callingState !== CallingState.RINGING) {
-      call.logger.info(
-        'Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.',
-        event,
-      );
-      return;
-    }
-    if (call.isCreatedByMe) {
-      const everyoneElseRejected = members
-        .filter((m) => m.user_id !== call.currentUserId)
-        .every((m) => rejectedBy[m.user_id]);
-      if (everyoneElseRejected) {
-        call.logger.info('everyone rejected, leaving the call');
-        await call.leave({
-          reject: true,
-          reason: 'cancel',
-          message: 'ring: everyone rejected',
-        });
-      }
-    } else {
-      if (rejectedBy[eventCall.created_by.id]) {
-        call.logger.info('call creator rejected, leaving call');
-        globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
-        await call.leave({ message: 'ring: creator rejected' });
-      }
-    }
-  };
-};
-
 /**
  * Event handler that watches the delivery of `call.ended` Websocket event.
  */