@stream-io/video-client 1.59.1 → 1.61.0

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

@@ -0,0 +1,199 @@
+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 { RingTimeout } from '../RingTimeout';
+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;
+
+describe('RingTimeout', () => {
+  const userId = 'jane';
+  let call: Call;
+  let ringTimeout: RingTimeout;
+
+  const ringingCall = ({
+    createdById = userId,
+    ring = {
+      auto_cancel_timeout_ms: TIMEOUT_MS,
+      incoming_call_timeout_ms: TIMEOUT_MS,
+      missed_call_timeout_ms: TIMEOUT_MS,
+    },
+  }: {
+    createdById?: string;
+    ring?: Partial<CallSettingsResponse['ring']> | null;
+  } = {}) => {
+    const clientStore = new StreamVideoWriteableStateStore();
+    const streamClient = new StreamClient('abc');
+    const newCall = new Call({
+      type: 'test',
+      id: generateUUIDv4(),
+      streamClient,
+      clientEventReporter: new ClientEventReporter({ streamClient }),
+      clientStore,
+    });
+
+    clientStore.setConnectedUser(fromPartial({ id: userId }));
+    newCall.state['createdBySubject'].next(fromPartial({ id: createdById }));
+    // leaving `settings` unset is how a call built from a push notification
+    // looks until `get()` resolves
+    if (ring) {
+      newCall.state['settingsSubject'].next(
+        fromPartial<CallSettingsResponse>({
+          ring,
+          screensharing: {
+            enabled: false,
+            target_resolution: { width: 100, height: 100 },
+          },
+        }),
+      );
+    }
+    newCall.state['callingStateSubject'].next(CallingState.RINGING);
+
+    vi.spyOn(newCall, 'leave').mockResolvedValue(undefined);
+    return newCall;
+  };
+
+  const arm = () => {
+    ringTimeout = new RingTimeout(call);
+    ringTimeout.start();
+    return ringTimeout;
+  };
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    ringTimeout?.stop();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('drops the call for the caller when no one accepted', async () => {
+    call = ringingCall();
+    arm();
+
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+
+    expect(call.leave).toHaveBeenCalledWith({
+      reject: true,
+      reason: 'timeout',
+      message: 'ringing timeout - no one accepted',
+    });
+  });
+
+  it('drops the call for a callee that never interacted', async () => {
+    call = ringingCall({ createdById: 'not-' + userId });
+    arm();
+
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+
+    expect(call.leave).toHaveBeenCalledWith({
+      reject: true,
+      reason: 'timeout',
+      message: `ringing timeout - user didn't interact with incoming call screen`,
+    });
+  });
+
+  it('does not drop the call before the timeout elapses', async () => {
+    call = ringingCall();
+    arm();
+
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS - 1);
+    expect(call.leave).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(call.leave).toHaveBeenCalled();
+  });
+
+  it('does not drop a call that stopped ringing before the deadline', async () => {
+    call = ringingCall();
+    arm();
+
+    call.state['callingStateSubject'].next(CallingState.JOINED);
+
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  // `doJoin` restores the ringing state when a join fails, so a transition to
+  // JOINING must not disarm the drop for good, or the call rings forever.
+  it('still drops the call after a join attempt failed and left it ringing', async () => {
+    call = ringingCall();
+    arm();
+
+    call.state['callingStateSubject'].next(CallingState.JOINING);
+    call.state['callingStateSubject'].next(CallingState.RINGING);
+
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).toHaveBeenCalledWith({
+      reject: true,
+      reason: 'timeout',
+      message: 'ringing timeout - no one accepted',
+    });
+  });
+
+  it('does not drop the call once stopped', async () => {
+    call = ringingCall();
+    arm().stop();
+
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  it('resumes from the original deadline after being paused', async () => {
+    call = ringingCall();
+    arm();
+
+    await vi.advanceTimersByTimeAsync(10_000);
+    ringTimeout.pause();
+    await vi.advanceTimersByTimeAsync(5_000);
+    ringTimeout.start();
+
+    await vi.advanceTimersByTimeAsync(14_999);
+    expect(call.leave).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(call.leave).toHaveBeenCalled();
+  });
+
+  it('does not arm when the call is not ringing', async () => {
+    call = ringingCall();
+    call.state['callingStateSubject'].next(CallingState.JOINED);
+    arm();
+
+    expect(ringTimeout['timeoutId']).toBeUndefined();
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  it('does not arm before the call settings have loaded', async () => {
+    call = ringingCall({ ring: null });
+    arm();
+
+    expect(ringTimeout['timeoutId']).toBeUndefined();
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  it('treats a zero timeout as no auto-drop', async () => {
+    call = ringingCall({
+      ring: {
+        auto_cancel_timeout_ms: 0,
+        incoming_call_timeout_ms: 0,
+        missed_call_timeout_ms: TIMEOUT_MS,
+      },
+    });
+    arm();
+
+    expect(ringTimeout['timeoutId']).toBeUndefined();
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,330 @@
+import { describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
+import { reconcileRingState } from '../reconcileRingState';
+import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import {
+  CallResponse,
+  CallSessionResponse,
+  MemberResponse,
+} from '../../gen/coordinator';
+import { Call } from '../../Call';
+import { StreamClient } from '../../coordinator/connection/client';
+import type { JoinSource } from '../../reporting';
+import { ClientEventReporter } from '../../reporting';
+import { settled } from '../../helpers/concurrency';
+
+describe('reconcileRingState', () => {
+  describe('acceptance', () => {
+    it('ignores an acceptance by the current user', async () => {
+      const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+      setSession(call, { accepted_by: { m1: timestamp() } });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.join).not.toHaveBeenCalled();
+    });
+
+    it('joins the call for the caller once a callee has accepted', async () => {
+      const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+      setSession(call, { accepted_by: { m2: timestamp() } });
+
+      expect(await reconcile(call)).toBe(true);
+      expect(call.join).toHaveBeenCalledWith({ joinSource: 'ring-ws' });
+    });
+
+    it('reports the poller as the source when the poll found the acceptance', async () => {
+      const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+      setSession(call, { accepted_by: { m2: timestamp() } });
+
+      expect(await reconcile(call, 'ring-poll-api')).toBe(true);
+      expect(call.join).toHaveBeenCalledWith({ joinSource: 'ring-poll-api' });
+    });
+
+    it('is not terminal when the join fails, so a retry can follow', async () => {
+      const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+      setSession(call, { accepted_by: { m2: timestamp() } });
+      vi.mocked(call.join).mockRejectedValueOnce(new Error('transient'));
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.join).toHaveBeenCalled();
+      expect(call.leave).not.toHaveBeenCalled();
+    });
+
+    it('does not join another callee when someone else accepts', async () => {
+      const call = ringingCall({ currentUserId: 'm2', createdById: 'm0' });
+      setSession(call, { accepted_by: { m1: timestamp() } });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.join).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('rejection', () => {
+    it('cancels the call once every callee has rejected', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm1',
+        members: ['m1', 'm2', 'm3'],
+      });
+      setSession(call, {
+        rejected_by: { m2: timestamp(), m3: timestamp() },
+      });
+
+      expect(await reconcile(call)).toBe(true);
+      expect(call.leave).toHaveBeenCalledWith({
+        reject: true,
+        reason: 'cancel',
+        message: 'ring: everyone rejected',
+      });
+    });
+
+    it('is not terminal when leaving fails, so a retry can follow', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm1',
+        members: ['m1', 'm2'],
+      });
+      setSession(call, { rejected_by: { m2: timestamp() } });
+      vi.mocked(call.leave).mockRejectedValueOnce(new Error('transient'));
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.leave).toHaveBeenCalled();
+    });
+
+    it('keeps ringing while only one callee has rejected', async () => {
+      const call = ringingCall({
+        currentUserId: 'm0',
+        createdById: 'm0',
+        members: ['m0', 'm1', 'm2'],
+      });
+      setSession(call, { rejected_by: { m2: timestamp() } });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.leave).not.toHaveBeenCalled();
+    });
+
+    it('leaves a callee once the caller has cancelled', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm0',
+        members: ['m0', 'm1', 'm2'],
+      });
+      setSession(call, { rejected_by: { m0: timestamp() } });
+
+      expect(await reconcile(call)).toBe(true);
+      expect(call.leave).toHaveBeenCalledWith({
+        reason: 'ended',
+        message: 'ring: creator rejected',
+      });
+    });
+
+    it('keeps a callee ringing while another callee rejects', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm0',
+        members: ['m0', 'm1', 'm2'],
+      });
+      setSession(call, { rejected_by: { m2: timestamp() } });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.leave).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('missed', () => {
+    it('keeps ringing when every callee is marked missed before auto-cancel', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm1',
+        members: ['m1', 'm2', 'm3'],
+      });
+      setSession(call, {
+        missed_by: { m2: timestamp(), m3: timestamp() },
+      });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.leave).not.toHaveBeenCalled();
+    });
+
+    it('keeps ringing when callees are split between rejected and missed', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm1',
+        members: ['m1', 'm2', 'm3'],
+      });
+      setSession(call, {
+        rejected_by: { m2: timestamp() },
+        missed_by: { m3: timestamp() },
+      });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.leave).not.toHaveBeenCalled();
+    });
+
+    it('keeps ringing while one callee can still accept', async () => {
+      const call = ringingCall({
+        currentUserId: 'm1',
+        createdById: 'm1',
+        members: ['m1', 'm2', 'm3'],
+      });
+      setSession(call, { missed_by: { m2: timestamp() } });
+
+      expect(await reconcile(call)).toBe(false);
+      expect(call.leave).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('ended call', () => {
+    it('leaves without rejecting, even when the call was accepted', async () => {
+      const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+      setSession(call, {
+        accepted_by: { m2: timestamp() },
+        ended_at: timestamp(),
+      });
+
+      expect(await reconcile(call)).toBe(true);
+      expect(call.join).not.toHaveBeenCalled();
+      expect(call.leave).toHaveBeenCalledWith({
+        reject: false,
+        reason: 'ended',
+        message: 'ring: call ended',
+      });
+    });
+
+    it('leaves when the call itself has ended', async () => {
+      const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+      setSession(call, {});
+      call.state.setEndedAt(new Date());
+
+      expect(await reconcile(call)).toBe(true);
+      expect(call.leave).toHaveBeenCalledWith({
+        reject: false,
+        reason: 'ended',
+        message: 'ring: call ended',
+      });
+    });
+  });
+
+  it('is terminal once the call is no longer ringing', async () => {
+    const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+    setSession(call, { accepted_by: { m2: timestamp() } });
+    call.state.setCallingState(CallingState.JOINED);
+
+    expect(await reconcile(call)).toBe(true);
+    expect(call.join).not.toHaveBeenCalled();
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+
+  // Pins the ordering the state-driven reconciler depends on: `Call.setup`
+  // registers `updateFromEvent` as an `all` listener, and `dispatchEvent`
+  // drains those before the typed ring handlers. Reconciling from state would
+  // silently read the previous session if either side changed.
+  it('sees the event data on the state by the time a ring handler runs', async () => {
+    const call = ringingCall({ currentUserId: 'm1', createdById: 'm1' });
+    await call.setup();
+    call.state.setCallingState(CallingState.RINGING);
+
+    call.streamClient.dispatchEvent(
+      fromPartial({
+        type: 'call.accepted',
+        call_cid: call.cid,
+        created_at: new Date().toISOString(),
+        user: { id: 'm2' },
+        call: {
+          ...callResponse('m1'),
+          session: {
+            id: 'session-1',
+            accepted_by: { m2: timestamp() },
+            rejected_by: {},
+            missed_by: {},
+            participants: [],
+            participants_count_by_role: {},
+          },
+        },
+      }),
+    );
+    await settled(call['joinLeaveConcurrencyTag']);
+
+    expect(call.join).toHaveBeenCalledWith({ joinSource: 'ring-ws' });
+  });
+
+  it('keeps ringing when the call has no members yet', async () => {
+    const call = ringingCall({
+      currentUserId: 'm1',
+      createdById: 'm1',
+      members: [],
+    });
+    setSession(call, {});
+
+    expect(await reconcile(call)).toBe(false);
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+});
+
+// the source only matters for the caller's join, so default it and let the
+// tests that assert on it pass their own
+const reconcile = (call: Call, joinSource: JoinSource = 'ring-ws') =>
+  reconcileRingState(call, joinSource);
+
+const timestamp = () => new Date().toISOString();
+
+const callResponse = (createdById: string) =>
+  fromPartial<CallResponse>({
+    id: '12345',
+    type: 'development',
+    cid: 'development:12345',
+    created_by: { id: createdById },
+    blocked_user_ids: [],
+    egress: {},
+    settings: {
+      ring: {
+        auto_cancel_timeout_ms: 30_000,
+        incoming_call_timeout_ms: 30_000,
+        missed_call_timeout_ms: 30_000,
+      },
+      screensharing: { target_resolution: undefined },
+    },
+  });
+
+const setSession = (call: Call, session: Partial<CallSessionResponse>) => {
+  call.state['sessionSubject'].next(
+    fromPartial({
+      accepted_by: {},
+      rejected_by: {},
+      missed_by: {},
+      ...session,
+    }),
+  );
+};
+
+const ringingCall = ({
+  currentUserId,
+  createdById,
+  members = [currentUserId, 'm2'],
+}: {
+  currentUserId: string;
+  createdById: string;
+  members?: string[];
+}) => {
+  const store = new StreamVideoWriteableStateStore();
+  store.setConnectedUser(fromPartial({ id: currentUserId }));
+  const streamClient = new StreamClient('api-key');
+  const call = new Call({
+    type: 'development',
+    id: '12345',
+    clientStore: store,
+    streamClient,
+    clientEventReporter: new ClientEventReporter({ streamClient }),
+    ringing: true,
+  });
+
+  call.state.updateFromCallResponse(callResponse(createdById));
+  call.state.setMembers(
+    members.map((userId) => fromPartial<MemberResponse>({ user_id: userId })),
+  );
+  call.state.setCallingState(CallingState.RINGING);
+
+  vi.spyOn(call, 'join').mockResolvedValue(undefined);
+  vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+
+  return call;
+};

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

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
+import {
+  type OwnRingOutcomeInput,
+  resolveOwnRingOutcome,
+} from '../resolveOwnRingOutcome';
+import { CallingState } from '../../store';
+import { CallSessionResponse } from '../../gen/coordinator';
+
+const ME = 'm1';
+const timestamp = () => new Date().toISOString();
+
+describe('resolveOwnRingOutcome', () => {
+  const resolve = (overrides: Partial<OwnRingOutcomeInput> = {}) =>
+    resolveOwnRingOutcome({
+      currentUserId: ME,
+      callingState: CallingState.RINGING,
+      ...overrides,
+      session: fromPartial<CallSessionResponse>({
+        accepted_by: {},
+        rejected_by: {},
+        missed_by: {},
+        ...overrides.session,
+      }),
+    });
+
+  it('reports nothing while nobody has acted', () => {
+    expect(resolve()).toEqual({ settledByMe: false });
+  });
+
+  it('reports nothing for another user accepting or rejecting', () => {
+    const outcome = resolve({
+      session: fromPartial({
+        accepted_by: { m2: timestamp() },
+        rejected_by: { m3: timestamp() },
+      }),
+    });
+
+    expect(outcome).toEqual({ settledByMe: false });
+  });
+
+  it('leaves when the ring was answered on another device', () => {
+    const outcome = resolve({
+      session: fromPartial({ accepted_by: { [ME]: timestamp() } }),
+    });
+
+    expect(outcome).toEqual({
+      settledByMe: true,
+      leaveReason: 'answeredElsewhere',
+    });
+  });
+
+  it('does not leave when this device is the one that accepted', () => {
+    const outcome = resolve({
+      callingState: CallingState.JOINING,
+      session: fromPartial({ accepted_by: { [ME]: timestamp() } }),
+    });
+
+    // the drop no longer has to fire, but this device is joining, not leaving
+    expect(outcome).toEqual({ settledByMe: true, leaveReason: undefined });
+  });
+
+  it('leaves when the current user rejected', () => {
+    const outcome = resolve({
+      session: fromPartial({ rejected_by: { [ME]: timestamp() } }),
+    });
+
+    expect(outcome).toEqual({ settledByMe: true, leaveReason: 'rejected' });
+  });
+
+  it('prefers the answered-elsewhere reason over a rejection', () => {
+    const outcome = resolve({
+      session: fromPartial({
+        accepted_by: { [ME]: timestamp() },
+        rejected_by: { [ME]: timestamp() },
+      }),
+    });
+
+    expect(outcome).toEqual({
+      settledByMe: true,
+      leaveReason: 'answeredElsewhere',
+    });
+  });
+
+  it('reports nothing without a connected user', () => {
+    const outcome = resolve({
+      currentUserId: undefined,
+      session: fromPartial({ rejected_by: { [ME]: timestamp() } }),
+    });
+
+    expect(outcome).toEqual({ settledByMe: false });
+  });
+
+  it('reports nothing without a session', () => {
+    expect(
+      resolveOwnRingOutcome({
+        session: undefined,
+        currentUserId: ME,
+        callingState: CallingState.RINGING,
+      }),
+    ).toEqual({ settledByMe: false });
+  });
+});

package/src/ringing/index.ts

@@ -0,0 +1,4 @@
+export * from './RingStatePoller';
+export * from './RingTimeout';
+export * from './reconcileRingState';
+export * from './resolveOwnRingOutcome';