@webex/plugin-meetings 3.0.0-beta.17 → 3.0.0-beta.19

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

@@ -22,7 +22,7 @@ import {
   LOCUSINFO,
   PC_BAIL_TIMEOUT,
 } from '@webex/plugin-meetings/src/constants';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState, Event, Errors, ErrorType, RemoteTrackType} from '@webex/internal-media-core';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
@@ -36,6 +36,7 @@ import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Media from '@webex/plugin-meetings/src/media/index';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
@@ -44,7 +45,12 @@ import Metrics from '@webex/plugin-meetings/src/metrics';
 import {trigger, eventType} from '@webex/plugin-meetings/src/metrics/config';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import {IceGatheringFailed} from '@webex/plugin-meetings/src/common/errors/webex-errors';
+import {MediaRequestManager} from '@webex/plugin-meetings/src/multistream/mediaRequestManager';
 
+import LLM from '@webex/internal-plugin-llm';
+import Mercury from '@webex/internal-plugin-mercury';
+import Breakouts from '@webex/plugin-meetings/src/breakouts';
+import {REACTION_RELAY_TYPES} from '../../../../src/reactions/constants';
 import locus from '../fixture/locus';
 import {
   UserNotJoinedError,
@@ -155,6 +161,8 @@ describe('plugin-meetings', () => {
         meetings: Meetings,
         credentials: Credentials,
         support: Support,
+        llm: LLM,
+        mercury: Mercury,
       },
       config: {
         credentials: {
@@ -179,6 +187,7 @@ describe('plugin-meetings', () => {
     webex.credentials.getOrgId = sinon.stub().returns('fake-org-id');
     webex.internal.metrics.submitClientMetrics = sinon.stub().returns(Promise.resolve());
     webex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
+    webex.internal.llm.on = sinon.stub();
 
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
@@ -250,6 +259,13 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.meetingInfoFailureReason, undefined);
           assert.equal(meeting.destination, testDestination);
           assert.equal(meeting.destinationType, _MEETING_ID_);
+          assert.instanceOf(meeting.breakouts, Breakouts);
+        });
+        it('creates MediaRequestManager instances', () => {
+          assert.instanceOf(meeting.mediaRequestManagers.audio, MediaRequestManager);
+          assert.instanceOf(meeting.mediaRequestManagers.video, MediaRequestManager);
+          assert.instanceOf(meeting.mediaRequestManagers.screenShareAudio, MediaRequestManager);
+          assert.instanceOf(meeting.mediaRequestManagers.screenShareVideo, MediaRequestManager);
         });
       });
       describe('#invite', () => {
@@ -779,7 +795,7 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should throw error', async () => {
+        it("should throw error if request doesn't work", async () => {
           meeting.request = sinon.stub().returns(Promise.reject());
 
           try {
@@ -799,6 +815,64 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.transcription.closeSocket);
         });
       });
+      describe('#isReactionsSupported', () => {
+        it('should return false if the feature is not supported for the meeting', () => {
+          meeting.locusInfo.controls = {reactions: {enabled: false}};
+
+          assert.equal(meeting.isReactionsSupported(), false);
+        });
+        it('should return true if the feature is not supported for the meeting', () => {
+          meeting.locusInfo.controls = {reactions: {enabled: true}};
+
+          assert.equal(meeting.isReactionsSupported(), true);
+        });
+      });
+      describe('#processRelayEvent', () => {
+        it('should process a Reaction event type', () => {
+          meeting.isReactionsSupported = sinon.stub().returns(true);
+          meeting.config.receiveReactions = true;
+          const fakeSendersName = 'Fake reactors name';
+          meeting.members.membersCollection.get = sinon.stub().returns({name: fakeSendersName});
+          const fakeReactionPayload = {
+            type: 'fake_type',
+            codepoints: 'fake_codepoints',
+            shortcodes: 'fake_shortcodes',
+            tone: {
+              type: 'fake_tone_type',
+              codepoints: 'fake_tone_codepoints',
+              shortcodes: 'fake_tone_shortcodes',
+            },
+          };
+          const fakeSenderPayload = {
+            participantId: 'fake_participant_id',
+          };
+          const fakeProcessedReaction = {
+            reaction: fakeReactionPayload,
+            sender: {
+              id: fakeSenderPayload.participantId,
+              name: fakeSendersName,
+            },
+          };
+          const fakeRelayEvent = {
+            data: {
+              relayType: REACTION_RELAY_TYPES.REACTION,
+              reaction: fakeReactionPayload,
+              sender: fakeSenderPayload,
+            }
+          };
+          meeting.processRelayEvent(fakeRelayEvent);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'join',
+            },
+            EVENT_TRIGGERS.MEETING_RECEIVE_REACTIONS,
+            fakeProcessedReaction
+          );
+        })
+      })
       describe('#join', () => {
         let sandbox = null;
         const joinMeetingResult = 'JOIN_MEETINGS_OPTION_RESULT';
@@ -844,15 +918,20 @@ describe('plugin-meetings', () => {
 
           it('should call updateLLMConnection upon joining if config value is set', async () => {
             meeting.config.enableAutomaticLLM = true;
+            meeting.webex.internal.llm.on = sinon.stub();
+            meeting.processRelayEvent = sinon.stub();
             await meeting.join();
 
             assert.calledOnce(meeting.updateLLMConnection);
+            assert.calledOnceWithExactly(meeting.webex.internal.llm.on, 'event:relay.event', meeting.processRelayEvent);
           });
 
           it('should not call updateLLMConnection upon joining if config value is not set', async () => {
+            meeting.webex.internal.llm.on = sinon.stub();
             await meeting.join();
 
             assert.notCalled(meeting.updateLLMConnection);
+            assert.notCalled(meeting.webex.internal.llm.on);
           });
 
           it('should invoke `receiveTranscription()` if receiveTranscription is set to true', async () => {
@@ -952,7 +1031,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           fakeMediaConnection = {
             close: sinon.stub(),
-            getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
             initiateOffer: sinon.stub().resolves({}),
             on: sinon.stub(),
           };
@@ -1200,7 +1279,7 @@ describe('plugin-meetings', () => {
           meeting.meetingState = 'ACTIVE';
           fakeMediaConnection.getConnectionState = sinon
             .stub()
-            .returns(MC.ConnectionState.Connecting);
+            .returns(ConnectionState.Connecting);
           const clock = sinon.useFakeTimers();
           const media = meeting.addMedia({
             mediaSettings: {},
@@ -2130,6 +2209,190 @@ describe('plugin-meetings', () => {
           );
           assert.isTrue(myPromiseResolved);
         });
+
+        it('should request floor only after roap transaction is completed', async () => {
+          const eventListeners = {};
+
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sandbox.stub().resolves(true)
+          };
+
+          const fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            }),
+
+            updateSendReceiveOptions: sinon.stub().callsFake(() => {
+              // trigger ROAP_STARTED before updateSendReceiveOptions() resolves
+              if (eventListeners[Event.ROAP_STARTED]) {
+                eventListeners[Event.ROAP_STARTED]();
+              } else {
+                throw new Error('ROAP_STARTED listener not registered')
+              }
+              return Promise.resolve();
+            }),
+          };
+
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
+
+          const requestScreenShareFloorStub = sandbox.stub(meeting, 'requestScreenShareFloor').resolves({});
+
+          let myPromiseResolved = false;
+
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {},
+          });
+
+          meeting
+            .updateMedia({
+              localShare: mockLocalShare,
+              mediaSettings: {
+                sendShare: true,
+              },
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.isFalse(myPromiseResolved);
+
+          // verify that requestScreenShareFloorStub was not called yet
+          assert.notCalled(requestScreenShareFloorStub);
+
+          eventListeners[Event.ROAP_DONE]();
+          await testUtils.flushPromises();
+
+          // now it should have been called
+          assert.calledOnce(requestScreenShareFloorStub);
+        });
+      });
+
+      describe('#updateShare', () => {
+        const mockLocalShare = {id: 'mock local share stream'};
+        let eventListeners;
+        let fakeMediaConnection;
+        let requestScreenShareFloorStub;
+
+        const FAKE_TRACKS = {
+          screenshareVideo: {
+            id: 'fake share track',
+            getSettings: sinon.stub().returns({}),
+          },
+        };
+
+        beforeEach(async () => {
+          eventListeners = {};
+
+          sinon.stub(MeetingUtil, 'getTrack').callsFake((stream) => {
+            if (stream === mockLocalShare) {
+              return {audioTrack: null, videoTrack: FAKE_TRACKS.screenshareVideo};
+            }
+
+            return {audioTrack: null, videoTrack: null};
+          });
+
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sinon.stub().resolves(true)
+          };
+
+          fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            }),
+
+            updateSendReceiveOptions: sinon.stub().callsFake(() => {
+              // trigger ROAP_STARTED before updateSendReceiveOptions() resolves
+              if (eventListeners[Event.ROAP_STARTED]) {
+                eventListeners[Event.ROAP_STARTED]();
+              } else {
+                throw new Error('ROAP_STARTED listener not registered')
+              }
+              return Promise.resolve();
+            }),
+          };
+
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
+
+          requestScreenShareFloorStub = sinon.stub(meeting, 'requestScreenShareFloor').resolves({});
+
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {},
+          });
+        });
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('when starting share, it should request floor only after roap transaction is completed', async () => {
+          let myPromiseResolved = false;
+
+          meeting
+            .updateShare({
+              sendShare: true,
+              receiveShare: true,
+              stream: mockLocalShare,
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.isFalse(myPromiseResolved);
+
+          // verify that requestScreenShareFloorStub was not called yet
+          assert.notCalled(requestScreenShareFloorStub);
+
+          eventListeners[Event.ROAP_DONE]();
+          await testUtils.flushPromises();
+
+          // now it should have been called
+          assert.calledOnce(requestScreenShareFloorStub);
+        });
+
+        it('when changing screen share stream and no roap transaction happening, it requests floor immediately', async () => {
+          let myPromiseResolved = false;
+
+          // simulate a case when no roap transaction is triggered by updateSendReceiveOptions
+          meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions = sinon.stub().resolves({});
+
+          meeting
+            .updateShare({
+              sendShare: true,
+              receiveShare: true,
+              stream: mockLocalShare,
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.calledOnce(requestScreenShareFloorStub);
+          assert.isTrue(myPromiseResolved);
+        });
       });
 
       describe('#changeVideoLayout', () => {
@@ -3531,19 +3794,19 @@ describe('plugin-meetings', () => {
 
         it('should register for all the correct RoapMediaConnection events', () => {
           meeting.setupMediaConnectionListeners();
-          assert.isFunction(eventListeners[MC.Event.ROAP_STARTED]);
-          assert.isFunction(eventListeners[MC.Event.ROAP_DONE]);
-          assert.isFunction(eventListeners[MC.Event.ROAP_FAILURE]);
-          assert.isFunction(eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]);
-          assert.isFunction(eventListeners[MC.Event.REMOTE_TRACK_ADDED]);
-          assert.isFunction(eventListeners[MC.Event.CONNECTION_STATE_CHANGED]);
+          assert.isFunction(eventListeners[Event.ROAP_STARTED]);
+          assert.isFunction(eventListeners[Event.ROAP_DONE]);
+          assert.isFunction(eventListeners[Event.ROAP_FAILURE]);
+          assert.isFunction(eventListeners[Event.ROAP_MESSAGE_TO_SEND]);
+          assert.isFunction(eventListeners[Event.REMOTE_TRACK_ADDED]);
+          assert.isFunction(eventListeners[Event.CONNECTION_STATE_CHANGED]);
         });
 
         it('should trigger a media:ready event when REMOTE_TRACK_ADDED is fired', () => {
           meeting.setupMediaConnectionListeners();
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
             track: 'track',
-            type: MC.RemoteTrackType.AUDIO,
+            type: RemoteTrackType.AUDIO,
           });
           assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {
@@ -3551,9 +3814,9 @@ describe('plugin-meetings', () => {
             stream: true,
           });
 
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
             track: 'track',
-            type: MC.RemoteTrackType.VIDEO,
+            type: RemoteTrackType.VIDEO,
           });
           assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
@@ -3561,9 +3824,9 @@ describe('plugin-meetings', () => {
             stream: true,
           });
 
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
             track: 'track',
-            type: MC.RemoteTrackType.SCREENSHARE_VIDEO,
+            type: RemoteTrackType.SCREENSHARE_VIDEO,
           });
           assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
@@ -3613,51 +3876,51 @@ describe('plugin-meetings', () => {
           };
 
           it('should send metrics for SdpOfferCreationError error', () => {
-            const fakeError = new MC.Errors.SdpOfferCreationError(fakeErrorMessage, {
+            const fakeError = new Errors.SdpOfferCreationError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.LOCAL_SDP_GENERATED);
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
-              MC.Errors.ErrorCode.SdpOfferCreationError,
+              Errors.ErrorCode.SdpOfferCreationError,
               fakeErrorMessage,
               fakeRootCauseName
             );
           });
 
           it('should send metrics for SdpOfferHandlingError error', () => {
-            const fakeError = new MC.Errors.SdpOfferHandlingError(fakeErrorMessage, {
+            const fakeError = new Errors.SdpOfferHandlingError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
-              MC.Errors.ErrorCode.SdpOfferHandlingError,
+              Errors.ErrorCode.SdpOfferHandlingError,
               fakeErrorMessage,
               fakeRootCauseName
             );
           });
 
           it('should send metrics for SdpAnswerHandlingError error', () => {
-            const fakeError = new MC.Errors.SdpAnswerHandlingError(fakeErrorMessage, {
+            const fakeError = new Errors.SdpAnswerHandlingError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
-              MC.Errors.ErrorCode.SdpAnswerHandlingError,
+              Errors.ErrorCode.SdpAnswerHandlingError,
               fakeErrorMessage,
               fakeRootCauseName
             );
@@ -3665,15 +3928,15 @@ describe('plugin-meetings', () => {
 
           it('should send metrics for SdpError error', () => {
             // SdpError is usually without a cause
-            const fakeError = new MC.Errors.SdpError(fakeErrorMessage, {name: fakeErrorName});
+            const fakeError = new Errors.SdpError(fakeErrorMessage, {name: fakeErrorName});
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.LOCAL_SDP_GENERATED);
             // expectedMetadataType is the error name in this case
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE,
-              MC.Errors.ErrorCode.SdpError,
+              Errors.ErrorCode.SdpError,
               fakeErrorMessage,
               fakeErrorName
             );
@@ -3681,24 +3944,24 @@ describe('plugin-meetings', () => {
 
           it('should send metrics for IceGatheringError error', () => {
             // IceGatheringError is usually without a cause
-            const fakeError = new MC.Errors.IceGatheringError(fakeErrorMessage, {
+            const fakeError = new Errors.IceGatheringError(fakeErrorMessage, {
               name: fakeErrorName,
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.LOCAL_SDP_GENERATED);
             // expectedMetadataType is the error name in this case
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE,
-              MC.Errors.ErrorCode.IceGatheringError,
+              Errors.ErrorCode.IceGatheringError,
               fakeErrorMessage,
               fakeErrorName
             );
           });
         });
 
-        describe('handles MC.Event.ROAP_MESSAGE_TO_SEND correctly', () => {
+        describe('handles Event.ROAP_MESSAGE_TO_SEND correctly', () => {
           let sendRoapOKStub;
           let sendRoapMediaRequestStub;
           let sendRoapAnswerStub;
@@ -3716,7 +3979,7 @@ describe('plugin-meetings', () => {
           });
 
           it('handles OK message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {messageType: 'OK', seq: 1},
             });
 
@@ -3735,7 +3998,7 @@ describe('plugin-meetings', () => {
           });
 
           it('handles OFFER message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'OFFER',
                 seq: 1,
@@ -3761,7 +4024,7 @@ describe('plugin-meetings', () => {
           });
 
           it('handles ANSWER message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ANSWER',
                 seq: 10,
@@ -3788,7 +4051,7 @@ describe('plugin-meetings', () => {
           it('sends metrics if fails to send roap ANSWER message', async () => {
             sendRoapAnswerStub.rejects(new Error('sending answer failed'));
 
-            await eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            await eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ANSWER',
                 seq: 10,
@@ -3810,9 +4073,9 @@ describe('plugin-meetings', () => {
             );
           });
 
-          [MC.ErrorType.CONFLICT, MC.ErrorType.DOUBLECONFLICT].forEach((errorType) =>
+          [ErrorType.CONFLICT, ErrorType.DOUBLECONFLICT].forEach((errorType) =>
             it(`handles ERROR message indicating glare condition correctly (errorType=${errorType})`, () => {
-              eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
                 roapMessage: {
                   messageType: 'ERROR',
                   seq: 10,
@@ -3843,11 +4106,11 @@ describe('plugin-meetings', () => {
           );
 
           it('handles ERROR message indicating other errors correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ERROR',
                 seq: 10,
-                errorType: MC.ErrorType.FAILED,
+                errorType: ErrorType.FAILED,
                 tieBreaker: 12345,
               },
             });
@@ -3857,7 +4120,7 @@ describe('plugin-meetings', () => {
             assert.calledOnce(sendRoapErrorStub);
             assert.calledWith(sendRoapErrorStub, {
               seq: 10,
-              errorType: MC.ErrorType.FAILED,
+              errorType: ErrorType.FAILED,
               mediaId: meeting.mediaId,
               correlationId: meeting.correlationId,
             });
@@ -3893,6 +4156,83 @@ describe('plugin-meetings', () => {
           );
           done();
         });
+
+        it('listens to the breakouts changed event', () => {
+          meeting.breakouts.updateBreakoutSessions = sinon.stub();
+
+          const payload = 'payload';
+
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_MEETING_BREAKOUTS_CHANGED', payload);
+
+          assert.calledOnceWithExactly(meeting.breakouts.updateBreakoutSessions, payload);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+          );
+        });
+      });
+
+      describe('#setUpBreakoutsListener', () => {
+        it('listens to the closing event from breakouts and triggers the closing event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('BREAKOUTS_CLOSING');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_CLOSING
+          );
+        });
+
+        it('listens to the message event from breakouts and triggers the message event', () => {
+          TriggerProxy.trigger.reset();
+
+          const messageEvent = 'message';
+
+          meeting.breakouts.trigger('MESSAGE', messageEvent);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_MESSAGE,
+            messageEvent
+          );
+        });
+
+        it('listens to the members update event from breakouts and triggers the breakouts update event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('MEMBERS_UPDATE');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+          );
+        });
+      });
+
+      describe('#setupLocusControlsListener', () => {
+        it('listens to the locus breakouts update event', () => {
+          const locus = {
+            breakout: 'breakout'
+          };
+
+          meeting.breakouts.updateBreakout = sinon.stub();
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'CONTROLS_MEETING_BREAKOUT_UPDATED', locus);
+
+          assert.calledOnceWithExactly(meeting.breakouts.updateBreakout, locus.breakout);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+          );
+        });
       });
 
       describe('#setUpLocusUrlListener', () => {
@@ -3900,18 +4240,47 @@ describe('plugin-meetings', () => {
           const newLocusUrl = 'newLocusUrl/12345';
 
           meeting.members = {locusUrlUpdate: sinon.stub().returns(Promise.resolve(test1))};
+          meeting.recordingController = {setLocusUrl: sinon.stub().returns(undefined)};
 
-          meeting.locusInfo.emit(
-            {function: 'test', file: 'test'},
-            'LOCUS_INFO_UPDATE_URL',
+          meeting.breakouts.locusUrlUpdate = sinon.stub();
+
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'LOCUS_INFO_UPDATE_URL', newLocusUrl);
+          assert.calledWith(
+            meeting.members.locusUrlUpdate,
             newLocusUrl
           );
+          assert.calledOnceWithExactly(meeting.breakouts.locusUrlUpdate, newLocusUrl);
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
+          assert.calledWith(meeting.recordingController.setLocusUrl, newLocusUrl);
           assert.equal(meeting.locusUrl, newLocusUrl);
           assert(meeting.locusId, '12345');
           done();
         });
       });
+
+      describe('#setUpLocusServicesListener', () => {
+        it('listens to the locus services update event', (done) => {
+          const newLocusServices = {
+              services: {
+                record: {
+                  url: 'url',
+                }
+              },
+          };
+
+          meeting.recordingController = {setServiceUrl: sinon.stub().returns(undefined), setSessionId: sinon.stub().returns(undefined)};
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'LINKS_SERVICES',
+            newLocusServices
+          );
+
+          assert.calledWith(meeting.recordingController.setServiceUrl, newLocusServices.services.record.url);
+          assert.calledOnce(meeting.recordingController.setSessionId);
+          done();
+        });
+      });
       describe('#setUpLocusInfoMediaInactiveListener', () => {
         it('listens to disconnect due to un activity ', (done) => {
           TriggerProxy.trigger.reset();
@@ -4319,7 +4688,7 @@ describe('plugin-meetings', () => {
         let inMeetingActionsSetSpy;
         let canUserLockSpy;
         let canUserUnlockSpy;
-        let canUserRecordSpy;
+        let canUserStartSpy;
         let canUserStopSpy;
         let canUserPauseSpy;
         let canUserResumeSpy;
@@ -4336,10 +4705,10 @@ describe('plugin-meetings', () => {
           locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
           canUserLockSpy = sinon.spy(MeetingUtil, 'canUserLock');
           canUserUnlockSpy = sinon.spy(MeetingUtil, 'canUserUnlock');
-          canUserRecordSpy = sinon.spy(MeetingUtil, 'canUserRecord');
-          canUserStopSpy = sinon.spy(MeetingUtil, 'canUserStop');
-          canUserPauseSpy = sinon.spy(MeetingUtil, 'canUserPause');
-          canUserResumeSpy = sinon.spy(MeetingUtil, 'canUserResume');
+          canUserStartSpy = sinon.spy(RecordingUtil, 'canUserStart');
+          canUserStopSpy = sinon.spy(RecordingUtil, 'canUserStop');
+          canUserPauseSpy = sinon.spy(RecordingUtil, 'canUserPause');
+          canUserResumeSpy = sinon.spy(RecordingUtil, 'canUserResume');
           inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
           canUserRaiseHandSpy = sinon.spy(MeetingUtil, 'canUserRaiseHand');
           canUserLowerAllHandsSpy = sinon.spy(MeetingUtil, 'canUserLowerAllHands');
@@ -4381,7 +4750,7 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(canUserLockSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserUnlockSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserRecordSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserStartSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserStopSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserPauseSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);