@webex/plugin-meetings 3.0.0-beta.85 → 3.0.0-beta.87

package/src/meeting/muteState.ts

@@ -1,15 +1,17 @@
+import {ServerMuteReason} from '@webex/media-helpers';
 import LoggerProxy from '../common/logs/logger-proxy';
 import ParameterError from '../common/errors/parameter';
 import PermissionError from '../common/errors/permission';
 import MeetingUtil from './util';
 import {AUDIO, VIDEO} from '../constants';
-
 /* Certain aspects of server interaction for video muting are not implemented as we currently don't support remote muting of video.
    If we ever need to support it, search for REMOTE_MUTE_VIDEO_MISSING_IMPLEMENTATION string to find the places that need updating
 */
 
 // eslint-disable-next-line import/prefer-default-export
-export const createMuteState = (type, meeting, mediaDirection) => {
+export const createMuteState = (type, meeting, mediaDirection, sdkOwnsLocalTrack: boolean) => {
+  // todo: remove mediaDirection argument (SPARK-399695)
+  // todo: remove the meeting argument  (SPARK-399695)
   if (type === AUDIO && !mediaDirection.sendAudio) {
     return null;
   }
@@ -21,7 +23,11 @@ export const createMuteState = (type, meeting, mediaDirection) => {
     `Meeting:muteState#createMuteState --> ${type}: creating MuteState for meeting id ${meeting?.id}`
   );
 
-  return new MuteState(type, meeting);
+  const muteState = new MuteState(type, meeting, sdkOwnsLocalTrack);
+
+  muteState.init(meeting);
+
+  return muteState;
 };
 
 /** The purpose of this class is to manage the local and remote mute state and make sure that the server state always matches
@@ -34,18 +40,23 @@ class MuteState {
   pendingPromiseResolve: any;
   state: any;
   type: any;
+  sdkOwnsLocalTrack: boolean; // todo: remove this when doing SPARK-399695
+  ignoreMuteStateChange: boolean;
 
   /**
    * Constructor
    *
    * @param {String} type - audio or video
    * @param {Object} meeting - the meeting object (used for reading current remote mute status)
+   * @param {boolean} sdkOwnsLocalTrack - if false, then client app owns the local track (for now that's the case only for multistream meetings)
    */
-  constructor(type: string, meeting: any) {
+  constructor(type: string, meeting: any, sdkOwnsLocalTrack: boolean) {
     if (type !== AUDIO && type !== VIDEO) {
       throw new ParameterError('Mute state is designed for handling audio or video only');
     }
     this.type = type;
+    this.sdkOwnsLocalTrack = sdkOwnsLocalTrack;
+    this.ignoreMuteStateChange = false;
     this.state = {
       client: {
         localMute: false,
@@ -63,6 +74,69 @@ class MuteState {
     this.pendingPromiseReject = null;
   }
 
+  /**
+   * Starts the mute state machine. Needs to be called after a new MuteState instance is created.
+   *
+   * @param {Object} meeting - the meeting object
+   * @returns {void}
+   */
+  public init(meeting: any) {
+    if (!this.sdkOwnsLocalTrack) {
+      this.applyUnmuteAllowedToTrack(meeting);
+
+      // if we are remotely muted, we need to apply that to the local track now (mute on-entry)
+      if (this.state.server.remoteMute) {
+        this.muteLocalTrack(meeting, this.state.server.remoteMute, 'remotelyMuted');
+      }
+
+      const initialMute =
+        this.type === AUDIO
+          ? meeting.mediaProperties.audioTrack?.muted
+          : meeting.mediaProperties.videoTrack?.muted;
+
+      LoggerProxy.logger.info(
+        `Meeting:muteState#start --> ${this.type}: local track initial mute state: ${initialMute}`
+      );
+
+      if (initialMute !== undefined) {
+        this.state.client.localMute = initialMute;
+
+        this.applyClientStateToServer(meeting);
+      }
+    }
+  }
+
+  /**
+   * This method needs to be called whenever the local audio/video track has changed.
+   * It reapplies the remote mute state onto the new track and also reads the current
+   * local mute state from the track and updates the internal state machine and sends
+   * any required requests to the server.
+   *
+   * @param {Object} meeting - the meeting object
+   * @returns {void}
+   */
+  public handleLocalTrackChange(meeting: any) {
+    return this.init(meeting);
+  }
+
+  /**
+   * Mutes/unmutes local track
+   *
+   * @param {Object} meeting - the meeting object
+   * @param {Boolean} mute - true to mute the track, false to unmute it
+   * @param {ServerMuteReason} reason - reason for muting/unmuting
+   * @returns {void}
+   */
+  private muteLocalTrack(meeting: any, mute: boolean, reason: ServerMuteReason) {
+    this.ignoreMuteStateChange = true;
+    if (this.type === AUDIO) {
+      meeting.mediaProperties.audioTrack?.setServerMuted(mute, reason);
+    } else {
+      meeting.mediaProperties.videoTrack?.setServerMuted(mute, reason);
+    }
+    this.ignoreMuteStateChange = false;
+  }
+
   /**
    * Handles mute/unmute request from the client/user. Returns a promise that's resolved once the server update is completed or
    * at the point that this request becomese superseded by another client request.
@@ -77,7 +151,8 @@ class MuteState {
    * @param {Boolean} [mute] true for muting, false for unmuting request
    * @returns {Promise}
    */
-  public handleClientRequest(meeting?: object, mute?: boolean) {
+  public handleClientRequest(meeting: object, mute?: boolean) {
+    // todo: this whole method will be removed in SPARK-399695
     LoggerProxy.logger.info(
       `Meeting:muteState#handleClientRequest --> ${this.type}: user requesting new mute state: ${mute}`
     );
@@ -89,8 +164,9 @@ class MuteState {
     }
 
     // we don't check if we're already in the same state, because even if we were, we would still have to apply the mute state locally,
-    // because the client may have changed the audio/vidoe tracks
+    // because the client may have changed the audio/video tracks
     this.state.client.localMute = mute;
+
     this.applyClientStateLocally(meeting);
 
     return new Promise((resolve, reject) => {
@@ -104,19 +180,51 @@ class MuteState {
     });
   }
 
+  /**
+   * This method should be called when the local track mute state is changed
+   * @public
+   * @memberof MuteState
+   * @param {Object} [meeting] the meeting object
+   * @param {Boolean} [mute] true for muting, false for unmuting request
+   * @returns {void}
+   */
+  public handleLocalTrackMuteStateChange(meeting?: object, mute?: boolean) {
+    if (this.ignoreMuteStateChange) {
+      return;
+    }
+    LoggerProxy.logger.info(
+      `Meeting:muteState#handleLocalTrackMuteStateChange --> ${this.type}: local track new mute state: ${mute}`
+    );
+
+    if (this.pendingPromiseReject) {
+      LoggerProxy.logger.error(
+        `Meeting:muteState#handleLocalTrackMuteStateChange --> ${this.type}: Local track mute state change handler called while a client request is handled - this should never happen!, mute state: ${mute}`
+      );
+    }
+
+    this.state.client.localMute = mute;
+
+    this.applyClientStateToServer(meeting);
+  }
+
   /**
    * Applies the current mute state to the local track (by enabling or disabling it accordingly)
    *
    * @public
    * @param {Object} [meeting] the meeting object
+   * @param {ServerMuteReason} reason - reason why we're applying our client state to the local track
    * @memberof MuteState
    * @returns {void}
    */
-  public applyClientStateLocally(meeting?: any) {
-    if (this.type === AUDIO) {
-      meeting.mediaProperties.audioTrack?.setMuted(this.state.client.localMute);
+  public applyClientStateLocally(meeting?: any, reason?: ServerMuteReason) {
+    if (this.sdkOwnsLocalTrack) {
+      if (this.type === AUDIO) {
+        meeting.mediaProperties.audioTrack?.setMuted(this.state.client.localMute);
+      } else {
+        meeting.mediaProperties.videoTrack?.setMuted(this.state.client.localMute);
+      }
     } else {
-      meeting.mediaProperties.videoTrack?.setMuted(this.state.client.localMute);
+      this.muteLocalTrack(meeting, this.state.client.localMute, reason);
     }
   }
 
@@ -190,6 +298,8 @@ class MuteState {
         }
         this.pendingPromiseResolve = null;
         this.pendingPromiseReject = null;
+
+        this.applyServerMuteToLocalTrack(meeting, 'clientRequestFailed');
       });
   }
 
@@ -265,24 +375,56 @@ class MuteState {
       });
   }
 
+  /** Sets the mute state of the local track according to what server thinks is our state
+   * @param {Object} meeting - the meeting object
+   * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local track
+   * @returns {void}
+   */
+  private applyServerMuteToLocalTrack(meeting: any, serverMuteReason: ServerMuteReason) {
+    if (!this.sdkOwnsLocalTrack) {
+      const muted = this.state.server.localMute || this.state.server.remoteMute;
+
+      // update the local track mute state, but not this.state.client.localMute
+      this.muteLocalTrack(meeting, muted, serverMuteReason);
+    }
+  }
+
+  /** Applies the current value for unmute allowed to the underlying track
+   *
+   * @param {Meeting} meeting
+   * @returns {void}
+   */
+  private applyUnmuteAllowedToTrack(meeting: any) {
+    if (!this.sdkOwnsLocalTrack) {
+      if (this.type === AUDIO) {
+        meeting.mediaProperties.audioTrack?.setUnmuteAllowed(this.state.server.unmuteAllowed);
+      } else {
+        meeting.mediaProperties.videoTrack?.setUnmuteAllowed(this.state.server.unmuteAllowed);
+      }
+    }
+  }
+
   /**
    * This method should be called whenever the server remote mute state is changed
    *
    * @public
    * @memberof MuteState
+   * @param {Meeting} meeting
    * @param {Boolean} [muted] true if user is remotely muted, false otherwise
    * @param {Boolean} [unmuteAllowed] indicates if user is allowed to unmute self (false when "hard mute" feature is used)
    * @returns {undefined}
    */
-  public handleServerRemoteMuteUpdate(muted?: boolean, unmuteAllowed?: boolean) {
+  public handleServerRemoteMuteUpdate(meeting: any, muted?: boolean, unmuteAllowed?: boolean) {
     LoggerProxy.logger.info(
       `Meeting:muteState#handleServerRemoteMuteUpdate --> ${this.type}: updating server remoteMute to (${muted})`
     );
-    if (muted !== undefined) {
-      this.state.server.remoteMute = muted;
-    }
     if (unmuteAllowed !== undefined) {
       this.state.server.unmuteAllowed = unmuteAllowed;
+      this.applyUnmuteAllowedToTrack(meeting);
+    }
+    if (muted !== undefined) {
+      this.state.server.remoteMute = muted;
+      this.applyServerMuteToLocalTrack(meeting, 'remotelyMuted');
     }
   }
 
@@ -299,6 +441,7 @@ class MuteState {
       `Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received -> doing local unmute`
     );
 
+    // todo: I'm seeing "you can now unmute yourself " popup  when this happens - but same thing happens on web.w.c so we can ignore for now
     this.state.server.remoteMute = false;
     this.state.client.localMute = false;
 
@@ -310,7 +453,7 @@ class MuteState {
       this.pendingPromiseReject = null;
     }
 
-    this.applyClientStateLocally(meeting);
+    this.applyClientStateLocally(meeting, 'localUnmuteRequired');
     this.applyClientStateToServer(meeting);
   }
 

package/src/meeting/util.ts

@@ -1,5 +1,5 @@
 import {isEmpty} from 'lodash';
-import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/internal-media-core';
+import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/media-helpers';
 
 import {MeetingNotActiveError, UserNotJoinedError} from '../common/errors/webex-errors';
 import Metrics from '../metrics';

package/src/meetings/index.ts

@@ -6,6 +6,8 @@ import '@webex/internal-plugin-conversation';
 import {WebexPlugin} from '@webex/webex-core';
 import {setLogger} from '@webex/internal-media-core';
 
+import * as mediaHelpersModule from '@webex/media-helpers';
+
 import 'webrtc-adapter';
 
 import Metrics from '../metrics';
@@ -149,6 +151,7 @@ export default class Meetings extends WebexPlugin {
   request: any;
   geoHintInfo: any;
   meetingInfo: any;
+  mediaHelpers: any;
 
   namespace = MEETINGS;
 
@@ -161,6 +164,17 @@ export default class Meetings extends WebexPlugin {
   constructor(...args) {
     super(...args);
 
+    /**
+     * The webrtc-core media helpers. This is a temporary solution required for the SDK sample app
+     * to be able to call media helper functions.
+     *
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof Meetings
+     */
+    this.mediaHelpers = mediaHelpersModule;
+
     /**
      * The Meetings request to interact with server
      * @instance

package/test/integration/spec/converged-space-meetings.js

@@ -6,6 +6,7 @@ import BrowserDetection from '@webex/plugin-meetings/dist/common/browser-detecti
 
 import {MEDIA_SERVERS} from '../../utils/constants';
 import testUtils from '../../utils/testUtils';
+import integrationTestUtils from '../../utils/integrationTestUtils';
 import webexTestUsers from '../../utils/webex-test-users';
 
 config();
@@ -142,9 +143,9 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: chris.meeting, event: 'media:negotiated'},
         ]);
 
-        const addMediaAlice = testUtils.addMedia(alice, {multistream: true, expectedMediaReadyTypes: ['local']});
-        const addMediaBob = testUtils.addMedia(bob, {multistream: true, expectedMediaReadyTypes: ['local']});
-        const addMediaChris = testUtils.addMedia(chris, {multistream: true, expectedMediaReadyTypes: ['local']});
+        const addMediaAlice = integrationTestUtils.addMedia(alice, {multistream: true});
+        const addMediaBob = integrationTestUtils.addMedia(bob, {multistream: true});
+        const addMediaChris = integrationTestUtils.addMedia(chris, {multistream: true});
 
         await addMediaAlice;
         await addMediaBob;

package/test/integration/spec/journey.js

@@ -9,6 +9,7 @@ import BrowserDetection from '@webex/plugin-meetings/dist/common/browser-detecti
 
 import DEFAULT_RESOLUTIONS from '../../../src/config';
 import testUtils from '../../utils/testUtils';
+import integrationTestUtils from '../../utils/integrationTestUtils';
 
 require('dotenv').config();
 
@@ -301,7 +302,7 @@ skipInNode(describe)('plugin-meetings', () => {
           })
           .then(() =>
             Promise.all([
-              testUtils.addMedia(alice),
+              integrationTestUtils.addMedia(alice),
               testUtils.waitForEvents([
                 {scope: alice.meeting, event: 'meeting:media:local:start', user: alice},
               ]),
@@ -330,7 +331,7 @@ skipInNode(describe)('plugin-meetings', () => {
 
       it('bob adds media to the meeting', () =>
         Promise.all([
-          testUtils.addMedia(bob),
+          integrationTestUtils.addMedia(bob),
           testUtils
             .waitForEvents([
               {scope: bob.meeting, event: 'meeting:media:local:start', user: bob},
@@ -886,7 +887,7 @@ skipInNode(describe)('plugin-meetings', () => {
                 );
               })
               .then(() => testUtils.waitForStateChange(chris.meeting, 'JOINED'))
-              .then(() => testUtils.addMedia(chris))
+              .then(() => integrationTestUtils.addMedia(chris))
               .then(() => assert(enumerateSpy.called));
           })
           .then(() =>

package/test/integration/spec/space-meeting.js

@@ -6,6 +6,7 @@ import MeetingInfoUtil from '@webex/plugin-meetings/dist/meeting-info/utilv2';
 
 import CMR from '../../utils/cmr';
 import testUtils from '../../utils/testUtils';
+import integrationTestUtils from '../../utils/integrationTestUtils';
 
 require('dotenv').config();
 
@@ -136,7 +137,7 @@ skipInNode(describe)('plugin-meetings', () => {
         .then(() => testUtils.waitForStateChange(chris.meeting, 'JOINED')));
 
     it('Bob and Alice addsMedia', () =>
-      testUtils.addMedia(bob).then(() => testUtils.addMedia(alice)));
+      integrationTestUtils.addMedia(bob).then(() => integrationTestUtils.addMedia(alice)));
 
     it('Bob has flowing streams on reconnect', () => {
       const retrieveStats = () => {
@@ -187,7 +188,7 @@ skipInNode(describe)('plugin-meetings', () => {
           ])
         )
         .then(() => testUtils.waitForStateChange(guest.meeting, 'JOINED'))
-        .then(() => testUtils.addMedia(guest))
+        .then(() => integrationTestUtils.addMedia(guest))
         .catch((e) => {
           console.error('Error chris joining the meeting ', e);
           throw e;
@@ -414,7 +415,7 @@ skipInNode(describe)('plugin-meetings', () => {
                 }),
             ])
               .then(() => testUtils.waitForStateChange(guest.meeting, 'JOINED'))
-              .then(() => testUtils.addMedia(guest));
+              .then(() => integrationTestUtils.addMedia(guest));
           })
           .catch((e) => {
             console.error('Error guest joining the meeting ', e);

package/test/unit/spec/media/index.ts

@@ -170,7 +170,6 @@ describe('createMediaConnection', () => {
           iceServers: [],
           enableMainAudio,
           enableMainVideo,
-          bundlePolicy: undefined,
         },
         'some debug id'
       );
@@ -201,10 +200,39 @@ describe('createMediaConnection', () => {
         iceServers: [],
         enableMainAudio: true,
         enableMainVideo: true,
-        bundlePolicy: undefined,
       },
       'debug string'
     );
+
+    it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
+      const multistreamRoapMediaConnectionConstructorStub = sinon
+        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .returns(fakeRoapMediaConnection);
+  
+      Media.createMediaConnection(true, 'debug string', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: false,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
+          },
+        },
+        bundlePolicy: undefined
+      });
+      assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+      assert.calledWith(
+        multistreamRoapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+          enableMainAudio: true,
+          enableMainVideo: true,
+        },
+        'debug string'
+      );
+    });
   });
 
   it('passes empty ICE servers array to RoapMediaConnection if turnServerInfo is undefined (multistream disabled)', () => {

package/test/unit/spec/meeting/index.js

@@ -3753,15 +3753,19 @@ describe('plugin-meetings', () => {
           audioTrack = {
             id: 'audio track',
             getSettings: sinon.stub().returns({}),
+            on: sinon.stub(),
+            off: sinon.stub(),
           };
           videoTrack = {
             id: 'video track',
             getSettings: sinon.stub().returns({}),
+            on: sinon.stub(),
+            off: sinon.stub(),
           };
           videoShareTrack = {
             id: 'share track',
             on: sinon.stub(),
-            removeEventListener: sinon.stub(),
+            off: sinon.stub(),
             getSettings: sinon.stub().returns({}),
           };
           meeting.requestScreenShareFloor = sinon.stub().resolves({});
@@ -3771,6 +3775,7 @@ describe('plugin-meetings', () => {
             sendVideo: false,
             sendShare: false,
           };
+          meeting.isMultistream = true;
           meeting.mediaProperties.webrtcMediaConnection = {
             publishTrack: sinon.stub().resolves({}),
             unpublishTrack: sinon.stub().resolves({}),
@@ -3814,10 +3819,7 @@ describe('plugin-meetings', () => {
             await assert.isRejected(meeting.publishTracks({audio: {id: 'some audio track'}}));
           });
 
-          const checkAudioPublished = () => {
-            assert.calledWith(MediaUtil.createMediaStream, [audioTrack]);
-            assert.calledOnce(LocalMicrophoneTrackConstructorStub);
-
+          const checkAudioPublished = (track) => {
             assert.calledWith(
               createMuteStateStub,
               'audio',
@@ -3826,16 +3828,13 @@ describe('plugin-meetings', () => {
             );
             assert.calledWith(
               meeting.mediaProperties.webrtcMediaConnection.publishTrack,
-              fakeLocalMicrophoneTrack
+              track
             );
-            assert.equal(meeting.mediaProperties.audioTrack, fakeLocalMicrophoneTrack);
+            assert.equal(meeting.mediaProperties.audioTrack, track);
             assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, true);
           };
 
-          const checkVideoPublished = () => {
-            assert.calledWith(MediaUtil.createMediaStream, [videoTrack]);
-            assert.calledOnce(LocalCameraTrackConstructorStub);
-
+          const checkVideoPublished = (track) => {
             assert.calledWith(
               createMuteStateStub,
               'video',
@@ -3844,23 +3843,20 @@ describe('plugin-meetings', () => {
             );
             assert.calledWith(
               meeting.mediaProperties.webrtcMediaConnection.publishTrack,
-              fakeLocalCameraTrack
+              track
             );
-            assert.equal(meeting.mediaProperties.videoTrack, fakeLocalCameraTrack);
+            assert.equal(meeting.mediaProperties.videoTrack, track);
             assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, true);
           };
 
-          const checkScreenShareVideoPublished = () => {
+          const checkScreenShareVideoPublished = (track) => {
             assert.calledOnce(meeting.requestScreenShareFloor);
 
-            assert.calledWith(MediaUtil.createMediaStream, [videoShareTrack]);
-            assert.calledOnce(LocalDisplayTrackConstructorStub);
-
             assert.calledWith(
               meeting.mediaProperties.webrtcMediaConnection.publishTrack,
-              fakeLocalDisplayTrack
+              track
             );
-            assert.equal(meeting.mediaProperties.shareTrack, fakeLocalDisplayTrack);
+            assert.equal(meeting.mediaProperties.shareTrack, track);
             assert.equal(meeting.mediaProperties.mediaDirection.sendShare, true);
           };
 
@@ -3868,7 +3864,7 @@ describe('plugin-meetings', () => {
             await meeting.publishTracks({screenShare: {video: videoShareTrack}});
 
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
-            checkScreenShareVideoPublished();
+            checkScreenShareVideoPublished(videoShareTrack);
           });
 
           it('creates MuteState instance and publishes the track for main audio', async () => {
@@ -3876,7 +3872,7 @@ describe('plugin-meetings', () => {
 
             assert.calledOnce(createMuteStateStub);
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
-            checkAudioPublished();
+            checkAudioPublished(audioTrack);
           });
 
           it('creates MuteState instance and publishes the track for main video', async () => {
@@ -3884,7 +3880,7 @@ describe('plugin-meetings', () => {
 
             assert.calledOnce(createMuteStateStub);
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
-            checkVideoPublished();
+            checkVideoPublished(videoTrack);
           });
 
           it('publishes audio, video and screen share together', async () => {
@@ -3898,9 +3894,9 @@ describe('plugin-meetings', () => {
 
             assert.calledTwice(createMuteStateStub);
             assert.calledThrice(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
-            checkAudioPublished();
-            checkVideoPublished();
-            checkScreenShareVideoPublished();
+            checkAudioPublished(audioTrack);
+            checkVideoPublished(videoTrack);
+            checkScreenShareVideoPublished(videoShareTrack);
           });
         });
 
@@ -3916,7 +3912,7 @@ describe('plugin-meetings', () => {
           const checkAudioUnpublished = () => {
             assert.calledWith(
               meeting.mediaProperties.webrtcMediaConnection.unpublishTrack,
-              fakeLocalMicrophoneTrack
+              audioTrack
             );
 
             assert.equal(meeting.mediaProperties.audioTrack, null);
@@ -3926,7 +3922,7 @@ describe('plugin-meetings', () => {
           const checkVideoUnpublished = () => {
             assert.calledWith(
               meeting.mediaProperties.webrtcMediaConnection.unpublishTrack,
-              fakeLocalCameraTrack
+              videoTrack
             );
 
             assert.equal(meeting.mediaProperties.videoTrack, null);
@@ -3936,7 +3932,7 @@ describe('plugin-meetings', () => {
           const checkScreenShareVideoUnpublished = () => {
             assert.calledWith(
               meeting.mediaProperties.webrtcMediaConnection.unpublishTrack,
-              fakeLocalDisplayTrack
+              videoShareTrack
             );
 
             assert.calledOnce(meeting.requestScreenShareFloor);