@webex/plugin-meetings 3.0.0-beta.35 → 3.0.0-beta.36

package/src/meeting/util.ts

@@ -1,4 +1,5 @@
 import {isEmpty} from 'lodash';
+import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/internal-media-core';
 
 import {MeetingNotActiveError, UserNotJoinedError} from '../common/errors/webex-errors';
 import Metrics from '../metrics';
@@ -390,11 +391,11 @@ MeetingUtil.unlockMeeting = (actions, request, locusUrl) => {
   return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
 };
 
-MeetingUtil.handleAudioLogging = (audioTrack) => {
+MeetingUtil.handleAudioLogging = (audioTrack: LocalMicrophoneTrack | null) => {
   const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
 
   if (audioTrack) {
-    const settings = audioTrack.getSettings();
+    const settings = audioTrack.underlyingTrack.getSettings();
     const {deviceId} = settings;
 
     LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
@@ -402,11 +403,11 @@ MeetingUtil.handleAudioLogging = (audioTrack) => {
   }
 };
 
-MeetingUtil.handleVideoLogging = (videoTrack) => {
+MeetingUtil.handleVideoLogging = (videoTrack: LocalCameraTrack | null) => {
   const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
 
   if (videoTrack) {
-    const settings = videoTrack.getSettings();
+    const settings = videoTrack.underlyingTrack.getSettings();
     const {deviceId} = settings;
 
     LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);

package/src/metrics/constants.ts

@@ -40,10 +40,6 @@ const BEHAVIORAL_METRICS = {
   INVALID_ICE_CANDIDATE: 'js_sdk_invalid_ice_candidate',
   UPLOAD_LOGS_FAILURE: 'js_sdk_upload_logs_failure',
   RECEIVE_TRANSCRIPTION_FAILURE: 'js_sdk_receive_transcription_failure',
-  ENABLE_BNR_SUCCESS: 'js_sdk_enable_bnr_success',
-  ENABLE_BNR_FAILURE: 'js_sdk_enable_bnr_failure',
-  DISABLE_BNR_SUCCESS: 'js_sdk_disable_bnr_success',
-  DISABLE_BNR_FAILURE: 'js_sdk_disable_bnr_failure',
   FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
   FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
   ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',

package/src/reconnection-manager/index.ts

@@ -476,7 +476,7 @@ export default class ReconnectionManager {
 
       if (wasSharing) {
         // Stop the share streams if user tried to rejoin
-        Media.stopTracks(this.meeting.mediaProperties.shareTrack);
+        this.meeting.setLocalShareTrack(null);
         this.meeting.isSharing = false;
         if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
           this.meeting.shareStatus = SHARE_STATUS.NO_SHARE;

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

@@ -142,9 +142,9 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: chris.meeting, event: 'media:negotiated'},
         ]);
 
-        const addMediaAlice = testUtils.addMedia(alice, {expectedMediaReadyTypes: ['local']});
-        const addMediaBob = testUtils.addMedia(bob, {expectedMediaReadyTypes: ['local']});
-        const addMediaChris = testUtils.addMedia(chris, {expectedMediaReadyTypes: ['local']});
+        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']});
 
         await addMediaAlice;
         await addMediaBob;

package/test/integration/spec/journey.js

@@ -605,7 +605,7 @@ skipInNode(describe)('plugin-meetings', () => {
         ]).then(() => {
           // TODO: Re-eanable Safari when screensharing issues have been resolved
           if (!isBrowser('safari')) {
-            assert.equal(alice.meeting.mediaProperties.shareTrack.getConstraints().height, 720);
+            assert.equal(alice.meeting.mediaProperties.shareTrack.underlyingTrack.getConstraints().height, 720);
           }
           assert.equal(alice.meeting.isSharing, true);
           assert.equal(alice.meeting.shareStatus, 'local_share_active');
@@ -646,7 +646,7 @@ skipInNode(describe)('plugin-meetings', () => {
           // TODO: Re-eanable Safari when screensharing issues have been resolved
           if (!isBrowser('safari')) {
             assert.equal(
-              bob.meeting.mediaProperties.shareTrack.getConstraints().height,
+              bob.meeting.mediaProperties.shareTrack.underlyingTrack.getConstraints().height,
               heightResolution
             );
           }
@@ -806,7 +806,7 @@ skipInNode(describe)('plugin-meetings', () => {
           // TODO: Re-eanable Safari when screensharing issues have been resolved
           if (!isBrowser('safari')) {
             assert.equal(
-              bob.meeting.mediaProperties.shareTrack.getConstraints().height,
+              bob.meeting.mediaProperties.shareTrack.underlyingTrack.getConstraints().height,
               heightResolution
             );
           }

package/test/unit/spec/breakouts/edit-lock-error.ts

@@ -0,0 +1,30 @@
+import BreakoutEditLockedError from '@webex/plugin-meetings/src/breakouts/edit-lock-error';
+import {assert, expect} from '@webex/test-helper-chai';
+import {ERROR_DICTIONARY} from '@webex/plugin-meetings/src/constants';
+import {BREAKOUTS} from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('edit-lock-error', () => {
+        it('check constructor paramter', () => {
+            const result = new BreakoutEditLockedError();
+            assert.equal(result.name, ERROR_DICTIONARY.BREAKOUT_EDIT.NAME);
+            assert.equal(result.sdkMessage, ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE);
+            assert.equal(result.code, ERROR_DICTIONARY.BREAKOUT_EDIT.CODE);
+            assert.equal(result.error, null);
+        });
+
+        it('check constructor paramter', () => {
+            const fakeError = {
+                body: {
+                  "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+                  "message":"Edit lock token mismatch"
+                }
+              };
+            const result = new BreakoutEditLockedError('message', fakeError);
+            assert.equal(result.name, ERROR_DICTIONARY.BREAKOUT_EDIT.NAME);
+            assert.equal(result.sdkMessage, ERROR_DICTIONARY.BREAKOUT_EDIT.MESSAGE);
+            assert.equal(result.code, ERROR_DICTIONARY.BREAKOUT_EDIT.CODE);
+            assert.equal(result.error, fakeError);
+        });
+    });
+});

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

@@ -7,7 +7,7 @@ import {BREAKOUTS} from '@webex/plugin-meetings/src/constants';
 import sinon from "sinon";
 import MockWebex from '@webex/test-helper-mock-webex';
 import testUtils from '../../../utils/testUtils';
-
+import BreakoutEditLockedError from "@webex/plugin-meetings/src/breakouts/edit-lock-error";
 
 describe('plugin-meetings', () => {
   describe('Breakouts', () => {
@@ -460,5 +460,96 @@ describe('plugin-meetings', () => {
         assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
     });
+
+    describe('delete', () => {
+      it('makes the request as expected', async () => {
+        webex.request.returns(Promise.resolve({
+          body: {
+            groups: [{
+              id : "455556a4-37cd-4baa-89bc-8730581a1cc0",
+              status : "CLOSE",
+              type : "BREAKOUT",
+            }]
+          }
+        }));
+
+        const result = await breakouts.clearSessions();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'url',
+          body: {
+            groups: [
+              {
+                action: BREAKOUTS.ACTION_TYPES.DELETE,
+              },
+            ],
+          }
+        });
+
+        assert.equal(breakouts.groups[0].status, "CLOSE")
+      });
+
+      it('rejects when edit lock token mismatch', async () => {
+        webex.request.returns(Promise.reject({
+          body: {
+            "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+            "message":"Edit lock token mismatch"
+          }
+        }));
+
+        await assert.isRejected(
+          breakouts.clearSessions(),
+          BreakoutEditLockedError,
+          'Edit lock token mismatch'
+        );
+
+      });
+    });
+
+    describe('create', () => {
+      it('response not include groups info', async () => {
+        const sessions = [{'name':'session1', "anyoneCanJoin" : true}];
+        const result = await breakouts.create(sessions);
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+      });
+
+      it('response include groups info', async () => {
+        const sessions = [{'name':'session1', "anyoneCanJoin" : true}];
+
+        webex.request.returns(Promise.resolve({
+          body: {
+            groups: [{
+              id : "455556a4-37cd-4baa-89bc-8730581a1cc0",
+              status : "PENDING",
+              type : "BREAKOUT",
+            }]
+          }
+        }));
+
+        const result = await breakouts.create(sessions);
+
+        assert.equal(breakouts.groups[0].id, "455556a4-37cd-4baa-89bc-8730581a1cc0")
+
+      });
+
+      it('rejects when edit lock token mismatch', async () => {
+        const sessions = [{'name':'session1', "anyoneCanJoin" : true}];
+
+        webex.request.returns(Promise.reject({
+          body: {
+            "errorCode":BREAKOUTS.ERROR_CODE.EDIT_LOCK_TOKEN_MISMATCH,
+            "message":"Edit lock token mismatch"
+          }
+        }));
+
+        await assert.isRejected(
+          breakouts.create(sessions),
+          BreakoutEditLockedError,
+          'Edit lock token mismatch'
+        );
+      });
+    });
   });
 });

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

@@ -10,9 +10,11 @@ describe('createMediaConnection', () => {
   };
   const fakeAudioTrack = {
     id: 'audio track',
+    underlyingTrack: 'underlying audio track',
   };
   const fakeVideoTrack = {
     id: 'video track',
+    underlyingTrack: 'underlying video track',
   };
 
   afterEach(() => {
@@ -80,9 +82,9 @@ describe('createMediaConnection', () => {
       },
       {
         send: {
-          audio: fakeAudioTrack,
-          video: fakeVideoTrack,
-          screenShareVideo: null,
+          audio: fakeAudioTrack.underlyingTrack,
+          video: fakeVideoTrack.underlyingTrack,
+          screenShareVideo: undefined,
         },
         receive: {
           audio: true,
@@ -190,9 +192,9 @@ describe('createMediaConnection', () => {
       },
       {
         send: {
-          audio: fakeAudioTrack,
-          video: null,
-          screenShareVideo: fakeVideoTrack,
+          audio: fakeAudioTrack.underlyingTrack,
+          video: undefined,
+          screenShareVideo: fakeVideoTrack.underlyingTrack,
         },
         receive: {
           audio: true,

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

@@ -22,7 +22,8 @@ import {
   LOCUSINFO,
   PC_BAIL_TIMEOUT,
 } from '@webex/plugin-meetings/src/constants';
-import {ConnectionState, Event, Errors, ErrorType, RemoteTrackType} from '@webex/internal-media-core';
+import * as InternalMediaCoreModule from '@webex/internal-media-core';
+import {ConnectionState, Event, Errors, ErrorType, LocalTrackEvents, RemoteTrackType} from '@webex/internal-media-core';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
 import * as MuteStateModule from '@webex/plugin-meetings/src/meeting/muteState';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
@@ -194,7 +195,11 @@ describe('plugin-meetings', () => {
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
-    MediaUtil.createMediaStream = sinon.stub().returns(true);
+    MediaUtil.createMediaStream = sinon.stub().callsFake((tracks) => {
+      return {
+        getTracks: () => tracks
+      };
+    });;
 
     uuid1 = uuid.v4();
     uuid2 = uuid.v4();
@@ -483,85 +488,6 @@ describe('plugin-meetings', () => {
             });
           });
         });
-        describe('#enableBNR', () => {
-          it('should have #enableBnr', () => {
-            assert.exists(meeting.enableBNR);
-          });
-
-          describe('before audio attached to meeting', () => {
-            it('should throw no audio error', async () => {
-              await meeting.enableBNR().catch((err) => {
-                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
-              });
-            });
-          });
-
-          describe('after audio attached to meeting', () => {
-            let handleClientRequest;
-
-            beforeEach(async () => {
-              await meeting.getMediaStreams();
-              await meeting.addMedia();
-            });
-
-            it('should throw error if meeting audio is muted', async () => {
-              const handleClientRequest = (meeting, mute) => {
-                meeting.mediaProperties.audioTrack.enabled = !mute;
-
-                return Promise.resolve();
-              };
-              const isMuted = () => !meeting.mediaProperties.audioTrack.enabled;
-
-              meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-              meeting.mediaId = 'mediaId';
-              meeting.audio = {handleClientRequest, isMuted};
-              await meeting.muteAudio();
-              await meeting.enableBNR().catch((err) => {
-                assert.equal(err.message, 'Cannot enable BNR while meeting is muted');
-              });
-            });
-
-            it('should return true on enable bnr success', async () => {
-              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
-              meeting.effects = {handleClientRequest};
-              const response = await meeting.enableBNR();
-
-              assert.equal(response, true);
-            });
-          });
-        });
-
-        describe('#disableBNR', () => {
-          describe('before audio attached to meeting', () => {
-            it('should have #disableBnr', () => {
-              assert.exists(meeting.disableBNR);
-            });
-
-            it('should throw no audio error', async () => {
-              await meeting.disableBNR().catch((err) => {
-                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
-              });
-            });
-          });
-          describe('after audio attached to meeting', () => {
-            beforeEach(async () => {
-              await meeting.getMediaStreams();
-              await meeting.addMedia();
-            });
-
-            let handleClientRequest;
-            let isBnrEnabled;
-
-            it('should return true on disable bnr success', async () => {
-              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
-              isBnrEnabled = sinon.stub().returns(Promise.resolve(true));
-              meeting.effects = {handleClientRequest, isBnrEnabled};
-              const response = await meeting.disableBNR();
-
-              assert.equal(response, true);
-            });
-          });
-        });
       });
       describe('#muteVideo', () => {
         it('should have #muteVideo', () => {
@@ -1311,8 +1237,7 @@ describe('plugin-meetings', () => {
             .addMedia({
               mediaSettings: {},
             })
-            .catch((error) => {
-              assert.equal(error.code, IceGatheringFailed.CODE);
+            .catch(() => {
               errorThrown = true;
             });
 
@@ -1700,26 +1625,30 @@ describe('plugin-meetings', () => {
 
           it('skips canUpdateMedia() check on contentTracks.onended', () => {
             const {mediaProperties} = meeting;
-            let registeredListener = null;
             const fakeTrack = {
               getSettings: sinon.stub().returns({}),
-              onended: sinon.stub(),
-              addEventListener: sinon.stub().callsFake((event, listener) => {
-                registeredListener = listener;
-              }),
             };
 
+            const listeners = {};
+
+            const fakeLocalDisplayTrack = {
+              on: sinon.stub().callsFake((event, listener) => {
+                listeners[event] = listener;
+              })
+            };
+            sinon.stub(InternalMediaCoreModule, 'LocalDisplayTrack').returns(fakeLocalDisplayTrack);
+
+
             sandbox.stub(mediaProperties, 'setLocalShareTrack');
-            sandbox.stub(mediaProperties, 'shareTrack').value(fakeTrack);
             sandbox.stub(mediaProperties, 'setMediaSettings');
             sandbox.stub(meeting, 'stopShare').resolves(true);
             meeting.setLocalShareTrack(fakeTrack);
 
-            assert.calledOnce(fakeTrack.addEventListener);
-            assert.calledWith(fakeTrack.addEventListener, 'ended', sinon.match.any);
-            assert.isNotNull(registeredListener);
+            assert.calledOnce(fakeLocalDisplayTrack.on);
+            assert.calledWith(fakeLocalDisplayTrack.on, LocalTrackEvents.Ended, sinon.match.any);
+            assert.isNotNull(listeners[LocalTrackEvents.Ended]);
 
-            registeredListener();
+            listeners[LocalTrackEvents.Ended]();
 
             assert.calledWith(meeting.stopShare, {skipSignalingCheck: true});
           });
@@ -2135,7 +2064,7 @@ describe('plugin-meetings', () => {
           screenshareVideo: {
             id: 'fake share track',
             getSettings: sinon.stub().returns({}),
-            addEventListener: sinon.stub()
+            on: sinon.stub()
           },
         };
 
@@ -2297,7 +2226,7 @@ describe('plugin-meetings', () => {
           screenshareVideo: {
             id: 'fake share track',
             getSettings: sinon.stub().returns({}),
-            addEventListener: sinon.stub(),
+            on: sinon.stub(),
           },
         };
 
@@ -3582,6 +3511,12 @@ describe('plugin-meetings', () => {
         let videoTrack;
         let videoShareTrack;
         let createMuteStateStub;
+        let LocalDisplayTrackConstructorStub;
+        let LocalMicrophoneTrackConstructorStub;
+        let LocalCameraTrackConstructorStub;
+        let fakeLocalDisplayTrack;
+        let fakeLocalMicrophoneTrack;
+        let fakeLocalCameraTrack;
 
         beforeEach(() => {
           audioTrack = {
@@ -3594,7 +3529,7 @@ describe('plugin-meetings', () => {
           };
           videoShareTrack = {
             id: 'share track',
-            addEventListener: sinon.stub(),
+            on: sinon.stub(),
             removeEventListener: sinon.stub(),
             getSettings: sinon.stub().returns({}),
           };
@@ -3606,6 +3541,28 @@ describe('plugin-meetings', () => {
             unpublishTrack: sinon.stub().resolves({}),
           };
 
+          const createFakeLocalTrack = (originalTrack) => ({
+            on: sinon.stub(),
+            off: sinon.stub(),
+            stop: sinon.stub(),
+            originalTrack
+          });
+
+          // setup mock constructors for webrtc-core local track classes in such a way
+          // that they return the original track correctly (this is needed for unpublish() API tests)
+          LocalDisplayTrackConstructorStub = sinon.stub(InternalMediaCoreModule, 'LocalDisplayTrack').callsFake((stream) => {
+            fakeLocalDisplayTrack = createFakeLocalTrack(stream.getTracks()[0])
+            return fakeLocalDisplayTrack;
+          });
+          LocalMicrophoneTrackConstructorStub = sinon.stub(InternalMediaCoreModule, 'LocalMicrophoneTrack').callsFake((stream) => {
+            fakeLocalMicrophoneTrack = createFakeLocalTrack(stream.getTracks()[0])
+            return fakeLocalMicrophoneTrack;
+          });
+          LocalCameraTrackConstructorStub = sinon.stub(InternalMediaCoreModule, 'LocalCameraTrack').callsFake((stream) => {
+            fakeLocalCameraTrack = createFakeLocalTrack(stream.getTracks()[0])
+            return fakeLocalCameraTrack;
+          });
+
           createMuteStateStub = sinon.stub(MuteStateModule, 'createMuteState').returns({id: 'fake mute state instance'});
         })
         describe('#publishTracks', () => {
@@ -3615,23 +3572,33 @@ describe('plugin-meetings', () => {
           });
 
           const checkAudioPublished = () => {
+            assert.calledWith(MediaUtil.createMediaStream, [audioTrack]);
+            assert.calledOnce(LocalMicrophoneTrackConstructorStub);
+
             assert.calledWith(createMuteStateStub, 'audio', meeting, meeting.mediaProperties.mediaDirection);
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, audioTrack, 'main');
-            assert.equal(meeting.mediaProperties.audioTrack, audioTrack);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, fakeLocalMicrophoneTrack);
+            assert.equal(meeting.mediaProperties.audioTrack, fakeLocalMicrophoneTrack);
             assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, true);
           }
 
           const checkVideoPublished = () => {
+            assert.calledWith(MediaUtil.createMediaStream, [videoTrack]);
+            assert.calledOnce(LocalCameraTrackConstructorStub);
+
             assert.calledWith(createMuteStateStub, 'video', meeting, meeting.mediaProperties.mediaDirection);
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, videoTrack, 'main');
-            assert.equal(meeting.mediaProperties.videoTrack, videoTrack);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, fakeLocalCameraTrack);
+            assert.equal(meeting.mediaProperties.videoTrack, fakeLocalCameraTrack);
             assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, true);
           }
 
           const checkScreenShareVideoPublished = () => {
             assert.calledOnce(meeting.requestScreenShareFloor);
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, videoShareTrack, 'slides');
-            assert.equal(meeting.mediaProperties.shareTrack, videoShareTrack);
+
+            assert.calledWith(MediaUtil.createMediaStream, [videoShareTrack]);
+            assert.calledOnce(LocalDisplayTrackConstructorStub);
+
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, fakeLocalDisplayTrack);
+            assert.equal(meeting.mediaProperties.shareTrack, fakeLocalDisplayTrack);
             assert.equal(meeting.mediaProperties.mediaDirection.sendShare, true);
           }
 
@@ -3685,21 +3652,21 @@ describe('plugin-meetings', () => {
           });
 
           const checkAudioUnpublished = () => {
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, audioTrack, 'main');
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, fakeLocalMicrophoneTrack);
 
             assert.equal(meeting.mediaProperties.audioTrack, null);
             assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, false);
           };
 
           const checkVideoUnpublished = () => {
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, videoTrack, 'main');
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, fakeLocalCameraTrack);
 
             assert.equal(meeting.mediaProperties.videoTrack, null);
             assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, false);
           }
 
           const checkScreenShareVideoUnpublished = () => {
-            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, videoShareTrack, 'slides');
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, fakeLocalDisplayTrack);
 
             assert.calledOnce(meeting.requestScreenShareFloor);
 
@@ -3924,7 +3891,6 @@ describe('plugin-meetings', () => {
       });
       describe('#setLocalShareTrack', () => {
         it('should trigger a media:ready event with local share stream', () => {
-          let registeredListener = null;
           const track = {
             getSettings: sinon.stub().returns({
               aspectRatio: '1.7',
@@ -3934,11 +3900,17 @@ describe('plugin-meetings', () => {
               displaySurface: true,
               cursor: true,
             }),
-            addEventListener: sinon.stub().callsFake((event, listener) => {
-              registeredListener = listener;
-            }),
           };
 
+          const listeners = {};
+          const fakeLocalDisplayTrack = {
+            on: sinon.stub().callsFake((event, listener) => {
+                listeners[event] = listener;
+              })
+          };
+          sinon.stub(InternalMediaCoreModule, 'LocalDisplayTrack').returns(fakeLocalDisplayTrack);
+
+
           meeting.mediaProperties.setLocalShareTrack = sinon.stub().returns(true);
           meeting.stopShare = sinon.stub().resolves(true);
           meeting.mediaProperties.mediaDirection = {};
@@ -3952,8 +3924,8 @@ describe('plugin-meetings', () => {
           );
           assert.calledOnce(meeting.mediaProperties.setLocalShareTrack);
           assert.equal(meeting.mediaProperties.localStream, undefined);
-          assert.isNotNull(registeredListener);
-          registeredListener();
+          assert.isNotNull(listeners[LocalTrackEvents.Ended]);
+          listeners[LocalTrackEvents.Ended]();
           assert.calledOnce(meeting.stopShare);
         });
       });
@@ -3969,6 +3941,7 @@ describe('plugin-meetings', () => {
               eventListeners[event] = listener;
             }),
           };
+          MediaUtil.createMediaStream.returns({id: 'stream'});
         });
 
         it('should register for all the correct RoapMediaConnection events', () => {
@@ -3990,7 +3963,7 @@ describe('plugin-meetings', () => {
           assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {
             type: 'remoteAudio',
-            stream: true,
+            stream: {id: 'stream'},
           });
 
           eventListeners[Event.REMOTE_TRACK_ADDED]({
@@ -4000,7 +3973,7 @@ describe('plugin-meetings', () => {
           assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
             type: 'remoteVideo',
-            stream: true,
+            stream: {id: 'stream'},
           });
 
           eventListeners[Event.REMOTE_TRACK_ADDED]({
@@ -4010,7 +3983,7 @@ describe('plugin-meetings', () => {
           assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
             type: 'remoteShare',
-            stream: true,
+            stream: {id: 'stream'},
           });
         });