@stream-io/video-client 1.20.0 → 1.20.2

package/dist/src/Call.d.ts

@@ -137,7 +137,7 @@ export declare class Call {
     /**
      * Leave the call and stop the media streams that were published by the call.
      */
-    leave: ({ reject, reason, }?: CallLeaveOptions) => Promise<void>;
+    leave: ({ reject, reason, message }?: CallLeaveOptions) => Promise<void>;
     /**
      * A flag indicating whether the call is "ringing" type of call.
      */

package/dist/src/devices/BrowserPermission.d.ts

@@ -20,6 +20,7 @@ export declare class BrowserPermission {
     }): Promise<boolean>;
     listen(cb: (state: BrowserPermissionState) => void): () => boolean;
     asObservable(): import("rxjs").Observable<boolean>;
+    asStateObservable(): import("rxjs").Observable<BrowserPermissionState>;
     getIsPromptingObservable(): import("rxjs").Observable<boolean>;
     private getStateObservable;
     private setState;

package/dist/src/devices/InputMediaDeviceManagerState.d.ts

@@ -1,6 +1,6 @@
 import { BehaviorSubject, Observable } from 'rxjs';
 import { RxUtils } from '../store';
-import { BrowserPermission } from './BrowserPermission';
+import { BrowserPermission, BrowserPermissionState } from './BrowserPermission';
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
 export type TrackDisableMode = 'stop-tracks' | 'disable-tracks';
 export declare abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
@@ -37,9 +37,14 @@ export declare abstract class InputMediaDeviceManagerState<C = MediaTrackConstra
     defaultConstraints$: Observable<C | undefined>;
     /**
      * An observable that will emit `true` if browser/system permission
-     * is granted, `false` otherwise.
+     * is granted (or at least hasn't been denied), `false` otherwise.
      */
     hasBrowserPermission$: Observable<boolean>;
+    /**
+     * An observable that emits with browser permission state changes.
+     * Gives more granular visiblity than hasBrowserPermission$.
+     */
+    browserPermissionState$: Observable<BrowserPermissionState>;
     /**
      * An observable that emits `true` when SDK is prompting for browser permission
      * (i.e. browser's UI for allowing or disallowing device access is visible)

package/dist/src/gen/coordinator/index.d.ts

@@ -3489,6 +3489,7 @@ export declare const FrameRecordingSettingsRequestQualityEnum: {
     readonly _720P: "720p";
     readonly _1080P: "1080p";
     readonly _1440P: "1440p";
+    readonly _2160P: "2160p";
 };
 export type FrameRecordingSettingsRequestQualityEnum = (typeof FrameRecordingSettingsRequestQualityEnum)[keyof typeof FrameRecordingSettingsRequestQualityEnum];
 /**
@@ -5216,11 +5217,13 @@ export declare const RTMPBroadcastRequestQualityEnum: {
     readonly _720P: "720p";
     readonly _1080P: "1080p";
     readonly _1440P: "1440p";
+    readonly _2160P: "2160p";
     readonly PORTRAIT_360X640: "portrait-360x640";
     readonly PORTRAIT_480X854: "portrait-480x854";
     readonly PORTRAIT_720X1280: "portrait-720x1280";
     readonly PORTRAIT_1080X1920: "portrait-1080x1920";
     readonly PORTRAIT_1440X2560: "portrait-1440x2560";
+    readonly PORTRAIT_2160X3840: "portrait-2160x3840";
 };
 export type RTMPBroadcastRequestQualityEnum = (typeof RTMPBroadcastRequestQualityEnum)[keyof typeof RTMPBroadcastRequestQualityEnum];
 /**
@@ -5264,11 +5267,13 @@ export declare const RTMPSettingsRequestQualityEnum: {
     readonly _720P: "720p";
     readonly _1080P: "1080p";
     readonly _1440P: "1440p";
+    readonly _2160P: "2160p";
     readonly PORTRAIT_360X640: "portrait-360x640";
     readonly PORTRAIT_480X854: "portrait-480x854";
     readonly PORTRAIT_720X1280: "portrait-720x1280";
     readonly PORTRAIT_1080X1920: "portrait-1080x1920";
     readonly PORTRAIT_1440X2560: "portrait-1440x2560";
+    readonly PORTRAIT_2160X3840: "portrait-2160x3840";
 };
 export type RTMPSettingsRequestQualityEnum = (typeof RTMPSettingsRequestQualityEnum)[keyof typeof RTMPSettingsRequestQualityEnum];
 /**
@@ -5366,11 +5371,13 @@ export declare const RecordSettingsRequestQualityEnum: {
     readonly _720P: "720p";
     readonly _1080P: "1080p";
     readonly _1440P: "1440p";
+    readonly _2160P: "2160p";
     readonly PORTRAIT_360X640: "portrait-360x640";
     readonly PORTRAIT_480X854: "portrait-480x854";
     readonly PORTRAIT_720X1280: "portrait-720x1280";
     readonly PORTRAIT_1080X1920: "portrait-1080x1920";
     readonly PORTRAIT_1440X2560: "portrait-1440x2560";
+    readonly PORTRAIT_2160X3840: "portrait-2160x3840";
 };
 export type RecordSettingsRequestQualityEnum = (typeof RecordSettingsRequestQualityEnum)[keyof typeof RecordSettingsRequestQualityEnum];
 /**

package/dist/src/types.d.ts

@@ -4,6 +4,7 @@ import type { StreamClient } from './coordinator/connection/client';
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
+import { RejectReason } from './coordinator/connection/types';
 export type StreamReaction = Pick<ReactionResponse, 'type' | 'emoji_code' | 'custom'>;
 export declare enum VisibilityState {
     UNKNOWN = "UNKNOWN",
@@ -182,9 +183,13 @@ export type CallLeaveOptions = {
     reject?: boolean;
     /**
      * The reason for leaving the call.
-     * This will be sent to the backend and will be visible in the logs.
+     * This will be sent as the `reason` field in the `call.rejected` event.
      */
-    reason?: string;
+    reason?: RejectReason;
+    /**
+     * You can provide extra information about why the call is being left and/or rejected, used for logging purposes.
+     */
+    message?: string;
 };
 /**
  * The options to pass to {@link Call} constructor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -374,7 +374,7 @@ export class Call {
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
           this.logger('info', 'Leaving call because of being blocked');
-          await this.leave({ reason: 'user blocked' }).catch((err) => {
+          await this.leave({ message: 'user blocked' }).catch((err) => {
             this.logger('error', 'Error leaving call after being blocked', err);
           });
         }
@@ -555,10 +555,7 @@ export class Call {
   /**
    * Leave the call and stop the media streams that were published by the call.
    */
-  leave = async ({
-    reject,
-    reason = 'user is leaving the call',
-  }: CallLeaveOptions = {}) => {
+  leave = async ({ reject, reason, message }: CallLeaveOptions = {}) => {
     await withoutConcurrency(this.joinLeaveConcurrencyTag, async () => {
       const callingState = this.state.callingState;
       if (callingState === CallingState.LEFT) {
@@ -578,7 +575,7 @@ export class Call {
 
       if (callingState === CallingState.RINGING && reject !== false) {
         if (reject) {
-          await this.reject('decline');
+          await this.reject(reason ?? 'decline');
         } else {
           // if reject was undefined, we still have to cancel the call automatically
           // when I am the creator and everyone else left the call
@@ -601,7 +598,9 @@ export class Call {
       this.publisher?.dispose();
       this.publisher = undefined;
 
-      await this.sfuClient?.leaveAndClose(reason);
+      await this.sfuClient?.leaveAndClose(
+        message ?? reason ?? 'user is leaving the call',
+      );
       this.sfuClient = undefined;
       this.dynascaleManager.setSfuClient(undefined);
 
@@ -1534,7 +1533,7 @@ export class Call {
       const { reconnectStrategy: strategy, error } = e;
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
-        this.leave({ reason: 'SFU instructed to disconnect' }).catch((err) => {
+        this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
           this.logger('warn', `Can't leave call after disconnect request`, err);
         });
       } else {
@@ -2339,12 +2338,15 @@ export class Call {
 
     // 0 means no auto-drop
     if (timeoutInMs <= 0) return;
-
     this.dropTimeout = setTimeout(() => {
       // the call might have stopped ringing by this point,
       // e.g. it was already accepted and joined
       if (this.state.callingState !== CallingState.RINGING) return;
-      this.leave({ reject: true, reason: 'timeout' }).catch((err) => {
+      this.leave({
+        reject: true,
+        reason: 'timeout',
+        message: `ringing timeout - ${this.isCreatedByMe ? 'no one accepted' : `user didn't interact with incoming call screen`}`,
+      }).catch((err) => {
         this.logger('error', 'Failed to drop call', err);
       });
     }, timeoutInMs);

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

@@ -0,0 +1,101 @@
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Call } from '../Call';
+import { StreamClient } from '../coordinator/connection/client';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { CallingState, StreamVideoWriteableStateStore } from '../store';
+
+describe('Auto drop ringing calls', () => {
+  let call: Call;
+  const userId = 'jane';
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+
+    const clientStore = new StreamVideoWriteableStateStore();
+    call = new Call({
+      type: 'test',
+      id: generateUUIDv4(),
+      streamClient: new StreamClient('abc'),
+      clientStore: clientStore,
+    });
+
+    // @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,
+        },
+      },
+    });
+
+    // @ts-expect-error mocking only what we need for the test
+    call.state['createdBySubject'].next({
+      id: userId,
+    });
+
+    // black-box test, calling private method
+    call['scheduleAutoDrop']();
+
+    await vi.runAllTimersAsync();
+
+    expect(call.leave).toHaveBeenCalledWith({
+      reject: true,
+      reason: 'timeout',
+      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,
+        },
+      },
+    });
+
+    // @ts-expect-error mocking only what we need for the test
+    call.state['createdBySubject'].next({
+      id: 'not-' + userId,
+    });
+
+    // black-box test, calling private method
+    call['scheduleAutoDrop']();
+
+    await vi.runAllTimersAsync();
+
+    expect(call.leave).toHaveBeenCalledWith({
+      reject: true,
+      reason: 'timeout',
+      message: `ringing timeout - user didn't interact with incoming call screen`,
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+});

package/src/devices/BrowserPermission.ts

@@ -139,6 +139,10 @@ export class BrowserPermission {
     );
   }
 
+  asStateObservable() {
+    return this.getStateObservable();
+  }
+
   getIsPromptingObservable() {
     return this.getStateObservable().pipe(
       map((state) => state === 'prompting'),

package/src/devices/InputMediaDeviceManager.ts

@@ -8,7 +8,7 @@ import { isReactNative } from '../helpers/platforms';
 import { Logger } from '../coordinator/connection/types';
 import { getLogger } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
-import { deviceIds$ } from './devices';
+import { deviceIds$, disposeOfMediaStream } from './devices';
 import {
   settled,
   withCancellation,
@@ -307,134 +307,146 @@ export abstract class InputMediaDeviceManager<
     this.logger('debug', 'Starting stream');
     let stream: MediaStream;
     let rootStream: Promise<MediaStream> | undefined;
-    if (
-      this.state.mediaStream &&
-      this.getTracks().every((t) => t.readyState === 'live')
-    ) {
-      stream = this.state.mediaStream;
-      this.enableTracks();
-    } else {
-      const defaultConstraints = this.state.defaultConstraints;
-      const constraints: MediaTrackConstraints = {
-        ...defaultConstraints,
-        deviceId: this.state.selectedDevice
-          ? { exact: this.state.selectedDevice }
-          : undefined,
-      };
-
-      /**
-       * Chains two media streams together.
-       *
-       * In our case, filters MediaStreams are derived from their parent MediaStream.
-       * However, once a child filter's track is stopped,
-       * the tracks of the parent MediaStream aren't automatically stopped.
-       * This leads to a situation where the camera indicator light is still on
-       * even though the user stopped publishing video.
-       *
-       * This function works around this issue by stopping the parent MediaStream's tracks
-       * as well once the child filter's tracks are stopped.
-       *
-       * It works by patching the stop() method of the child filter's tracks to also stop
-       * the parent MediaStream's tracks of the same type. Here we assume that
-       * the parent MediaStream has only one track of each type.
-       *
-       * @param parentStream the parent MediaStream. Omit for the root stream.
-       */
-      const chainWith =
-        (parentStream?: Promise<MediaStream>) =>
-        async (filterStream: MediaStream): Promise<MediaStream> => {
-          if (!parentStream) return filterStream;
-          // TODO OL: take care of track.enabled property as well
-          const parent = await parentStream;
-          filterStream.getTracks().forEach((track) => {
-            const originalStop = track.stop;
-            track.stop = function stop() {
-              originalStop.call(track);
-              parent.getTracks().forEach((parentTrack) => {
-                if (parentTrack.kind === track.kind) {
-                  parentTrack.stop();
-                }
-              });
-            };
-          });
 
-          parent.getTracks().forEach((parentTrack) => {
-            // When the parent stream abruptly ends, we propagate the event
-            // to the filter stream.
-            // This usually happens when the camera/microphone permissions
-            // are revoked or when the device is disconnected.
-            const handleParentTrackEnded = () => {
-              filterStream.getTracks().forEach((track) => {
-                if (parentTrack.kind !== track.kind) return;
-                track.stop();
-                track.dispatchEvent(new Event('ended')); // propagate the event
+    try {
+      if (
+        this.state.mediaStream &&
+        this.getTracks().every((t) => t.readyState === 'live')
+      ) {
+        stream = this.state.mediaStream;
+        this.enableTracks();
+      } else {
+        const defaultConstraints = this.state.defaultConstraints;
+        const constraints: MediaTrackConstraints = {
+          ...defaultConstraints,
+          deviceId: this.state.selectedDevice
+            ? { exact: this.state.selectedDevice }
+            : undefined,
+        };
+
+        /**
+         * Chains two media streams together.
+         *
+         * In our case, filters MediaStreams are derived from their parent MediaStream.
+         * However, once a child filter's track is stopped,
+         * the tracks of the parent MediaStream aren't automatically stopped.
+         * This leads to a situation where the camera indicator light is still on
+         * even though the user stopped publishing video.
+         *
+         * This function works around this issue by stopping the parent MediaStream's tracks
+         * as well once the child filter's tracks are stopped.
+         *
+         * It works by patching the stop() method of the child filter's tracks to also stop
+         * the parent MediaStream's tracks of the same type. Here we assume that
+         * the parent MediaStream has only one track of each type.
+         *
+         * @param parentStream the parent MediaStream. Omit for the root stream.
+         */
+        const chainWith =
+          (parentStream?: Promise<MediaStream>) =>
+          async (filterStream: MediaStream): Promise<MediaStream> => {
+            if (!parentStream) return filterStream;
+            // TODO OL: take care of track.enabled property as well
+            const parent = await parentStream;
+            filterStream.getTracks().forEach((track) => {
+              const originalStop = track.stop;
+              track.stop = function stop() {
+                originalStop.call(track);
+                parent.getTracks().forEach((parentTrack) => {
+                  if (parentTrack.kind === track.kind) {
+                    parentTrack.stop();
+                  }
+                });
+              };
+            });
+
+            parent.getTracks().forEach((parentTrack) => {
+              // When the parent stream abruptly ends, we propagate the event
+              // to the filter stream.
+              // This usually happens when the camera/microphone permissions
+              // are revoked or when the device is disconnected.
+              const handleParentTrackEnded = () => {
+                filterStream.getTracks().forEach((track) => {
+                  if (parentTrack.kind !== track.kind) return;
+                  track.stop();
+                  track.dispatchEvent(new Event('ended')); // propagate the event
+                });
+              };
+              parentTrack.addEventListener('ended', handleParentTrackEnded);
+              this.subscriptions.push(() => {
+                parentTrack.removeEventListener(
+                  'ended',
+                  handleParentTrackEnded,
+                );
               });
-            };
-            parentTrack.addEventListener('ended', handleParentTrackEnded);
-            this.subscriptions.push(() => {
-              parentTrack.removeEventListener('ended', handleParentTrackEnded);
             });
-          });
 
-          return filterStream;
+            return filterStream;
+          };
+
+        // the rootStream represents the stream coming from the actual device
+        // e.g. camera or microphone stream
+        rootStream = this.getStream(constraints as C);
+        // we publish the last MediaStream of the chain
+        stream = await this.filters.reduce(
+          (parent, entry) =>
+            parent
+              .then((inputStream) => {
+                const { stop, output } = entry.start(inputStream);
+                entry.stop = stop;
+                return output;
+              })
+              .then(chainWith(parent), (error) => {
+                this.logger(
+                  'warn',
+                  'Filter failed to start and will be ignored',
+                  error,
+                );
+                return parent;
+              }),
+          rootStream,
+        );
+      }
+      if (this.call.state.callingState === CallingState.JOINED) {
+        await this.publishStream(stream);
+      }
+      if (this.state.mediaStream !== stream) {
+        this.state.setMediaStream(stream, await rootStream);
+        const handleTrackEnded = async () => {
+          await this.statusChangeSettled();
+          if (this.enabled) {
+            this.isTrackStoppedDueToTrackEnd = true;
+            setTimeout(() => {
+              this.isTrackStoppedDueToTrackEnd = false;
+            }, 2000);
+            await this.disable();
+          }
         };
-
-      // the rootStream represents the stream coming from the actual device
-      // e.g. camera or microphone stream
-      rootStream = this.getStream(constraints as C);
-      // we publish the last MediaStream of the chain
-      stream = await this.filters.reduce(
-        (parent, entry) =>
-          parent
-            .then((inputStream) => {
-              const { stop, output } = entry.start(inputStream);
-              entry.stop = stop;
-              return output;
-            })
-            .then(chainWith(parent), (error) => {
-              this.logger(
-                'warn',
-                'Filter failed to start and will be ignored',
-                error,
-              );
-              return parent;
-            }),
-        rootStream,
-      );
-    }
-    if (this.call.state.callingState === CallingState.JOINED) {
-      await this.publishStream(stream);
-    }
-    if (this.state.mediaStream !== stream) {
-      this.state.setMediaStream(stream, await rootStream);
-      const handleTrackEnded = async () => {
-        await this.statusChangeSettled();
-        if (this.enabled) {
-          this.isTrackStoppedDueToTrackEnd = true;
-          setTimeout(() => {
-            this.isTrackStoppedDueToTrackEnd = false;
-          }, 2000);
-          await this.disable();
-        }
-      };
-      const createTrackMuteHandler = (muted: boolean) => () => {
-        if (!isMobile() || this.trackType !== TrackType.VIDEO) return;
-        this.call.notifyTrackMuteState(muted, this.trackType).catch((err) => {
-          this.logger('warn', 'Error while notifying track mute state', err);
-        });
-      };
-      stream.getTracks().forEach((track) => {
-        const muteHandler = createTrackMuteHandler(true);
-        const unmuteHandler = createTrackMuteHandler(false);
-        track.addEventListener('mute', muteHandler);
-        track.addEventListener('unmute', unmuteHandler);
-        track.addEventListener('ended', handleTrackEnded);
-        this.subscriptions.push(() => {
-          track.removeEventListener('mute', muteHandler);
-          track.removeEventListener('unmute', unmuteHandler);
-          track.removeEventListener('ended', handleTrackEnded);
+        const createTrackMuteHandler = (muted: boolean) => () => {
+          if (!isMobile() || this.trackType !== TrackType.VIDEO) return;
+          this.call.notifyTrackMuteState(muted, this.trackType).catch((err) => {
+            this.logger('warn', 'Error while notifying track mute state', err);
+          });
+        };
+        stream.getTracks().forEach((track) => {
+          const muteHandler = createTrackMuteHandler(true);
+          const unmuteHandler = createTrackMuteHandler(false);
+          track.addEventListener('mute', muteHandler);
+          track.addEventListener('unmute', unmuteHandler);
+          track.addEventListener('ended', handleTrackEnded);
+          this.subscriptions.push(() => {
+            track.removeEventListener('mute', muteHandler);
+            track.removeEventListener('unmute', unmuteHandler);
+            track.removeEventListener('ended', handleTrackEnded);
+          });
         });
-      });
+      }
+    } catch (err) {
+      if (rootStream) {
+        disposeOfMediaStream(await rootStream);
+      }
+
+      throw err;
     }
   }
 

package/src/devices/InputMediaDeviceManagerState.ts

@@ -6,7 +6,7 @@ import {
   shareReplay,
 } from 'rxjs';
 import { RxUtils } from '../store';
-import { BrowserPermission } from './BrowserPermission';
+import { BrowserPermission, BrowserPermissionState } from './BrowserPermission';
 
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
 export type TrackDisableMode = 'stop-tracks' | 'disable-tracks';
@@ -63,10 +63,16 @@ export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
 
   /**
    * An observable that will emit `true` if browser/system permission
-   * is granted, `false` otherwise.
+   * is granted (or at least hasn't been denied), `false` otherwise.
    */
   hasBrowserPermission$: Observable<boolean>;
 
+  /**
+   * An observable that emits with browser permission state changes.
+   * Gives more granular visiblity than hasBrowserPermission$.
+   */
+  browserPermissionState$: Observable<BrowserPermissionState>;
+
   /**
    * An observable that emits `true` when SDK is prompting for browser permission
    * (i.e. browser's UI for allowing or disallowing device access is visible)
@@ -88,6 +94,10 @@ export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
       ? permission.asObservable().pipe(shareReplay(1))
       : of(true);
 
+    this.browserPermissionState$ = permission
+      ? permission.asStateObservable().pipe(shareReplay(1))
+      : of('prompt');
+
     this.isPromptingPermission$ = permission
       ? permission.getIsPromptingObservable().pipe(shareReplay(1))
       : of(false);

package/src/devices/__tests__/mocks.ts

@@ -221,5 +221,6 @@ export const emitDeviceIds = (values: MediaDeviceInfo[]) => {
 
 export const mockBrowserPermission = {
   asObservable: () => of(true),
+  asStateObservable: () => of('prompt'),
   getIsPromptingObservable: () => of(false),
 } as BrowserPermission;

package/src/events/__tests__/call.test.ts

@@ -114,7 +114,11 @@ describe('Call ringing events', () => {
           },
         },
       });
-      expect(call.leave).toHaveBeenCalled();
+      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 () => {