@webex/plugin-meetings 2.14.2 → 2.14.3

package/test/unit/spec/fixture/locus.js

@@ -0,0 +1,404 @@
+export default {
+  url: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b',
+  created: '2018-06-21T02:06:32.207Z',
+  info: {
+    topic: '',
+    sipUri: 'arun@cisco.webex.com',
+    maxParticipants: 1000,
+    webExRosterSyncEnabled: true,
+    webExMeetingId: '20519228',
+    globalMeetingId: '632D9CB5908CF13BE05FC0ABA26',
+    webExSite: 'cisco.webex.com',
+    webExMeetingName: 'ARUN  Personal Room',
+    isPmr: true,
+    webexServiceType: 'MEETING_CENTER',
+    meetingAvatarUrl: 'https://cisco.webex.com/webappng/images/avatars/ag.png?type=initials&initials=ag',
+    owner: '344ea183-9d5d-4e77-aed2-c4f004afd',
+    siteOrgId: '1eb65fdf-9643-417f-9974-ad72ca',
+    callInTollNumber: '+1-408-525-6',
+    callInNumbers: [
+      {
+        number: '+1-408-525-',
+        tollfree: false,
+        label: 'Call-in toll number (US/Canada)'
+      }
+    ],
+    isSparkPstnEnabled: true,
+    isCallInEnabled: true,
+    isGlobalCallInEnabled: true,
+    isCallOutEnabled: true,
+    isGlobalCallOutEnabled: true,
+    displayHints: {
+      joined: [
+        'WAITING_FOR_OTHERS',
+        'RECORDING_STATUS_STOPPED',
+        'LOCK_STATUS_UNLOCKED',
+        'ROSTER_IN_MEETING',
+        'SHARE_WHITEBOARD',
+        'SHARE_WHITEBOARD_POLICY',
+        'WEBEX_ASSISTANT_STATUS_INACTIVE',
+        'CAPTION_START',
+        'DISPLAY_REAL_TIME_TRANSLATION',
+        'ENABLE_CAPTION_PANEL',
+        'RAISE_HAND',
+        'REACTIONS_ACTIVE',
+        'REACTIONS_ACTIVE_SHOW_DISPLAY_NAME',
+        'UCF_SUPPRESS_BREAKOUTS_SUPPORT',
+        'UCF_SUPPRESS_MOBILE_BREAKOUTS_SUPPORT',
+        'DISABLE_ASK_FOR_HELP',
+        'STAGE_VIEW_INACTIVE',
+        'IMMERSIVE_PRESENTER_SUPPORTED_FOR_MTG'
+      ],
+      moderator: [
+        'RECORDING_CONTROL_START',
+        'TRANSCRIPTION_CONTROL_START',
+        'DISPLAY_NON_ENGLISH_ASR',
+        'PRESENTER_CONTROL',
+        'MUTE_ALL',
+        'UNMUTE_ALL',
+        'MUTE_OTHER',
+        'MUTE_VIDEO_OTHER',
+        'LOCK_CONTROL_LOCK',
+        'MODERATOR_ASSIGNMENT_CONTROL',
+        'ENABLE_MUTE_ON_ENTRY',
+        'DISABLE_REACTIONS',
+        'ENABLE_HARD_MUTE',
+        'ADD_GUEST',
+        'EXPEL',
+        'ENABLE_STAGE_VIEW'
+      ],
+      coHost: [
+        'LOCK_CONTROL_LOCK',
+        'ENABLE_HARD_MUTE',
+        'ENABLE_MUTE_ON_ENTRY',
+        'MUTE_ALL',
+        'UNMUTE_ALL',
+        'DISABLE_REACTIONS',
+        'MUTE_OTHER',
+        'MUTE_VIDEO_OTHER',
+        'TRANSCRIPTION_CONTROL_START',
+        'DISPLAY_NON_ENGLISH_ASR',
+        'PRESENTER_CONTROL',
+        'ENABLE_STAGE_VIEW',
+        'EXPEL',
+        'ADD_GUEST'
+      ]
+    },
+    venueUrl: 'https://calliope-a.wbx2.com/calliope/api/v1/venues/b84e1830-74f7-11e8-',
+    datachannelUrl: 'https://board-a.wbx2.com/datachannel/api/v1/locus/aHR0cHM6Ly9sb2N1cy1hsb2NpL2FjYTAwMTViLTQ1ODctMzNiZi05NGRjLTE2NTBmZDMyY2Q4NQ==/registrations',
+    embeddedAppsListUrl: 'https://hecate-a.wbx2.com/apps/api/v1/locus/aca0015b-4587-33bf-94dc-/embeddedApps/allowed?sessionInfo=eyJhbGci.',
+    embeddedAppsLaunchUrl: 'https://hecate-a.wbx2.com/apps/api/v1/locus/aca0015b-4587-33bf-94dc/embeddedApps?sessionInfo=eyJhbGciOiJub25lIn0.eyJza.',
+    meetingInstanceId: '632D9CB5908CF13BE053D107FC0ABA26_I_2331',
+    webexSiteUuid: '4C675B882686B136'
+  },
+  host: {
+    id: '344ea183-9d5d-4e77-aed2-c4f',
+    name: 'Arun Ganeshan',
+    isExternal: false,
+    orgId: '1eb65fdf-9643-417f-997',
+    incomingCallProtocols: []
+  },
+  fullState: {
+    active: true,
+    count: 1,
+    locked: false,
+    state: 'ACTIVE',
+    type: 'MEETING',
+    lastActive: '2022-07-26T20:32:22.964Z',
+    sessionIds: [],
+    sessionId: '3762f03e-598a-29dd-1ae7'
+  },
+  meetings: [],
+  controls: {
+    lock: {
+      locked: false,
+      meta: {}
+    },
+    record: {
+      recording: false,
+      meta: {
+        readOnly: false
+      }
+    },
+    transcribe: {
+      transcribing: false,
+      postMeetingTranscribing: false,
+      caption: false,
+      meta: {}
+    },
+    meetingFull: {
+      meetingFull: false,
+      meta: {}
+    },
+    muteOnEntry: {
+      enabled: false,
+      meta: {}
+    },
+    shareControl: {
+      control: 'ANYONE',
+      meta: {}
+    },
+    disallowUnmute: {
+      enabled: false,
+      meta: {}
+    },
+    videoLayout: {
+      layoutName: {
+        defaultName: 'Equal',
+        singleScreenDefaultName: 'ActivePresence'
+      }
+    },
+    reactions: {
+      enabled: true,
+      meta: {
+        modifiedBy: '344ea183-9d5d-4e77-aed2',
+        lastModified: '2022-07-26T20:32:22.964Z'
+      },
+      reactionChannelUrl: 'https://media-encryption-a.wbx2.com/reaction/api/v1/channels/e0b7b747-67f0-4b89',
+      showDisplayNameWithReactions: true
+    },
+    viewTheParticipantList: {
+      enabled: true,
+      meta: {
+        lastModified: '2022-07-26T20:32:22.964Z'
+      }
+    }
+  },
+  participants: [
+    {
+      isCreator: true,
+      identity: '344ea183-9d5d-4e77',
+      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/participant/e0d54e94-226c-3290-b75a-83cc1dbf1554',
+      state: 'JOINED',
+      type: 'USER',
+      isSiteInternal: true,
+      person: {
+        id: '344ea183-9d5d-4e77-aed2',
+        name: 'Arun Ganeshan',
+        isExternal: false,
+        orgId: '1eb65fdf-9643-417f-9974-ad72cae0e10f',
+        incomingCallProtocols: []
+      },
+      devices: [
+        {
+          url: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/85e6e2a0-2514-4fc2-a175',
+          deviceType: 'WEB',
+          state: 'JOINED',
+          intents: [
+            null
+          ],
+          correlationId: 'b05b4263-8fe3-427e-9995-e6f0a13302',
+          isVideoCallback: false,
+          csis: [],
+          replaces: []
+        }
+      ],
+      status: {
+        audioStatus: 'UNKNOWN',
+        videoStatus: 'UNKNOWN',
+        csis: []
+      },
+      controls: {
+        audio: {
+          muted: false,
+          requestedToUnmute: false,
+          disallowUnmute: false,
+          meta: {}
+        },
+        video: {
+          muted: false,
+          meta: {}
+        },
+        role: {
+          roles: [
+            {
+              type: 'COHOST',
+              hasRole: true,
+              meta: {
+                lastModified: '2022-07-26T20:32:22.964Z'
+              }
+            },
+            {
+              type: 'MODERATOR',
+              hasRole: true,
+              meta: {
+                lastModified: '2022-07-26T20:32:22.964Z'
+              }
+            },
+            {
+              type: 'ATTENDEE',
+              hasRole: true,
+              meta: {
+                lastModified: '2022-07-26T20:32:22.964Z',
+                readOnly: true
+              }
+            }
+          ]
+        }
+      },
+      doesNotSupportBreakouts: true,
+      identityTrustLevel: 'INTERNAL',
+      id: 'e0d54e94-226c-3290-b75a-83cc1dbf',
+      guest: false,
+      resourceGuest: false,
+      moderator: true,
+      panelist: false,
+      moveToLobbyNotAllowed: true,
+      cmrHost: true,
+      deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/85e6e2a0-2514-4fc2-a175'
+    }
+  ],
+  self: {
+    deviceUrl: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/85e6e2a0-2514-4fc2-a175',
+    alertHint: {
+      action: 'NONE'
+    },
+    alertType: {
+      action: 'NONE'
+    },
+    callbackInfo: {
+      callbackAddress: 'arungane@cisco.webex.com',
+      callbackType: 'SIPURI'
+    },
+    lookUpInfo: {
+      lookupLink: 'https://locus-a.wbx2.com/locus/api/v1/loci/meetingInfo/aca0015b-4587-33bf-94dc?type=LOCUS_ID&useUriLookup=false',
+      type: 'MEETING'
+    },
+    isCreator: true,
+    identity: '344ea183-9d5d-4e77-aed2-c4f004afd915',
+    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/participant/e0d54e94-226c-3290-b75a',
+    state: 'JOINED',
+    type: 'USER',
+    person: {
+      id: '344ea183-9d5d-4e77-aed2',
+      name: 'Arun Ganeshan',
+      isExternal: false,
+      orgId: '1eb65fdf-9643-417f-9974',
+      incomingCallProtocols: []
+    },
+    devices: [
+      {
+        url: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/85e6e2a0-2514-4fc2-a175',
+        deviceType: 'WEB',
+        state: 'JOINED',
+        intents: [
+          null
+        ],
+        keepAliveUrl: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf',
+        keepAliveSecs: 300,
+        callLegId: '80f5e939-1149-4f13-9535',
+        correlationId: 'b05b4263-8fe3-427e-9995',
+        isVideoCallback: false,
+        csis: [],
+        serverTranscoded: false,
+        serverComposed: false,
+        replaces: []
+      }
+    ],
+    status: {
+      audioStatus: 'UNKNOWN',
+      videoStatus: 'UNKNOWN',
+      csis: []
+    },
+    suggestedMedia: [
+      {
+        mediaType: 'audio',
+        mediaContent: 'main',
+        direction: 'sendrecv'
+      },
+      {
+        mediaType: 'video',
+        mediaContent: 'main',
+        direction: 'sendrecv'
+      },
+      {
+        mediaType: 'video',
+        mediaContent: 'slides',
+        direction: 'sendrecv'
+      }
+    ],
+    controls: {
+      audio: {
+        muted: false,
+        requestedToUnmute: false,
+        disallowUnmute: false,
+        meta: {}
+      },
+      video: {
+        muted: false,
+        meta: {}
+      },
+      role: {
+        roles: [
+          {
+            type: 'COHOST',
+            hasRole: true,
+            meta: {
+              lastModified: '2022-07-26T20:32:22.964Z'
+            }
+          },
+          {
+            type: 'MODERATOR',
+            hasRole: true,
+            meta: {
+              lastModified: '2022-07-26T20:32:22.964Z'
+            }
+          },
+          {
+            type: 'ATTENDEE',
+            hasRole: true,
+            meta: {
+              lastModified: '2022-07-26T20:32:22.964Z',
+              readOnly: true
+            }
+          }
+        ]
+      }
+    },
+    enableDTMF: true,
+    id: 'e0d54e94-226c-3290-b75a',
+    guest: false,
+    resourceGuest: false,
+    moderator: true,
+    panelist: false,
+    moveToLobbyNotAllowed: true,
+    cmrHost: true,
+    mediaBaseUrl: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/participant/e0d54e94-226c-3290-b75a-83cc1dbf1554/media'
+  },
+  mediaShares: [
+    {
+      name: 'content',
+      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/mediashares/337f77f9-2f27-3cb3-ba55'
+    },
+    {
+      name: 'whiteboardview',
+      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/mediashares/98891810-efb6-3aa3-b600-8654539abf46'
+    },
+    {
+      name: 'whiteboard',
+      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/mediashares/b8f1742b-5dc5-3d7a-b97f-39ae11f8a051'
+    }
+  ],
+  embeddedApps: [],
+  replaces: [],
+  sequence: {
+    entries: [
+      138781603429640000
+    ],
+    rangeStart: 0,
+    rangeEnd: 0,
+    since: '138781603429640000',
+    sequenceHash: 42,
+    dataCenter: 'achm3',
+    totalParticipants: 1,
+    dirtyParticipants: 0
+  },
+  syncUrl: 'https://locus-a.wbx2.com/locus/api/v1/loci/aca0015b-4587-33bf-94dc/sync?since=138781603429640000&sequenceHash=42',
+  links: {
+    services: {
+      breakout: {
+        url: 'https://breakout-a.wbx2.com/breakout/api/v1'
+      }
+    }
+  }
+};

package/test/unit/spec/locus-info/index.js

@@ -619,6 +619,33 @@ describe('plugin-meetings', () => {
         LOCUSINFO.EVENTS.LOCAL_UNMUTE_REQUESTED,
         {});
       });
+
+
+      it('should trigger SELF_OBSERVING when moving meeting to DX', () => {
+        locusInfo.self = self;
+        const selfInitiatedMove = cloneDeep(self);
+
+        // Inital move meeting is iniated
+        selfInitiatedMove.devices[0].intent.type = 'MOVE_MEDIA';
+
+        locusInfo.webex.internal.device.url = self.deviceUrl;
+
+        locusInfo.updateSelf(selfInitiatedMove, []);
+
+        locusInfo.emitScoped = sinon.stub();
+        // When dx joined the meeting after move
+        const selfAfterDxJoins = cloneDeep(self);
+
+        selfAfterDxJoins.devices[0].intent.type = 'OBSERVE';
+
+        locusInfo.updateSelf(selfAfterDxJoins, []);
+
+        assert.calledWith(locusInfo.emitScoped, {
+          file: 'locus-info',
+          function: 'updateSelf'
+        },
+        LOCUSINFO.EVENTS.SELF_OBSERVING);
+      });
     });
 
     describe('#updateMeetingInfo', () => {

package/test/unit/spec/locus-info/selfConstant.js

@@ -66,6 +66,7 @@ export const self = {
       ],
       mediaSessionsExternal: false,
       state: 'JOINED',
+      intent: {type: ''},
       intents: [
         null
       ],

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

@@ -42,6 +42,7 @@ import {
 } from '@webex/plugin-meetings/src/constants';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
+import locus from '../fixture/locus';
 import {
   UserNotJoinedError,
   MeetingNotActiveError,
@@ -2561,6 +2562,7 @@ describe('plugin-meetings', () => {
           assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
         });
       });
+
       describe('#mediaNegotiatedEvent', () => {
         it('should have #mediaNegotiatedEvent', () => {
           assert.exists(meeting.mediaNegotiatedEvent);
@@ -2638,6 +2640,222 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.roap?.stop);
         });
       });
+
+      describe('#moveTo', () => {
+        let sandbox;
+
+        beforeEach(() => {
+          sandbox = sinon.createSandbox();
+          sandbox.stub(meeting, 'closeLocalStream');
+          sandbox.stub(meeting, 'closeLocalShare');
+
+          sandbox.stub(meeting.mediaProperties, 'setMediaDirection');
+          sandbox.stub(meeting.mediaProperties, 'unsetMediaTracks');
+
+          sandbox.stub(meeting.reconnectionManager, 'reconnectMedia').returns(Promise.resolve());
+          sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}})));
+        });
+
+        afterEach(() => {
+          sandbox.restore();
+          sandbox = null;
+        });
+
+        it('should throw an error if resourceId not passed', async () => {
+          try {
+            await meeting.moveTo();
+          }
+          catch (err) {
+            assert.instanceOf(err, ParameterError);
+            assert.equal(err.sdkMessage, 'Cannot move call without a resourceId.');
+          }
+        });
+
+        it('should postEvent on moveTo ', async () => {
+          await meeting.moveTo('resourceId');
+          assert.calledWithMatch(Metrics.postEvent, {
+            event: eventType.MEDIA_CAPABILITIES,
+            data: {
+              mediaCapabilities: {
+                rx: {
+                  audio: false,
+                  share: true,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false
+                },
+                tx: {
+                  audio: false,
+                  share: false,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false
+                }
+              }
+            }
+          });
+          assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
+        });
+
+        it('should call `MeetingUtil.joinMeetingOptions` with resourceId', async () => {
+          sinon.spy(MeetingUtil, 'joinMeetingOptions');
+          await meeting.moveTo('resourceId');
+
+          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting, {resourceId: 'resourceId', moveToResource: true});
+        });
+
+        it('should reconnectMedia after DX joins after moveTo', async () => {
+          await meeting.moveTo('resourceId');
+
+
+          await meeting.locusInfo.emitScoped(
+            {
+              file: 'locus-info',
+              function: 'updateSelf'
+            },
+            'SELF_OBSERVING'
+          );
+
+          // beacuse we are calling callback so we need to wait
+
+          assert.called(meeting.closeLocalStream);
+          assert.called(meeting.closeLocalShare);
+
+          // give queued Promise callbacks a chance to run
+          await Promise.resolve();
+
+          assert.called(meeting.mediaProperties.setMediaDirection);
+          assert.called(meeting.mediaProperties.unsetMediaTracks);
+
+          assert.calledWith(meeting.reconnectionManager.reconnectMedia,
+            {
+              mediaDirection: {
+                sendVideo: false,
+                receiveVideo: false,
+                sendAudio: false,
+                receiveAudio: false,
+                sendShare: false,
+                receiveShare: true
+              }
+            });
+        });
+
+        it('should throw an error if moveTo call fails', async () => {
+          MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveTo('resourceId');
+          }
+          catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MOVE_TO_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: sinon.match.any,
+                stack: sinon.match.any
+              }
+            );
+          }
+          Metrics.sendBehavioralMetric.reset();
+          meeting.reconnectionManager.reconnectMedia = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveTo('resourceId');
+
+            await meeting.locusInfo.emitScoped(
+              {
+                file: 'locus-info',
+                function: 'updateSelf'
+              },
+              'SELF_OBSERVING'
+            );
+          }
+          catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MOVE_TO_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: sinon.match.any,
+                stack: sinon.match.any
+              }
+            );
+          }
+        });
+      });
+
+      describe('#moveFrom', () => {
+        let sandbox;
+
+        beforeEach(() => {
+          sandbox = sinon.createSandbox();
+          sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}})));
+          sandbox.stub(MeetingUtil, 'leaveMeeting').returns(Promise.resolve());
+        });
+
+        afterEach(() => {
+          sandbox.restore();
+          sandbox = null;
+        });
+
+        it('should throw an error if resourceId not passed', async () => {
+          try {
+            await meeting.moveFrom();
+          }
+          catch (err) {
+            assert.instanceOf(err, ParameterError);
+
+            assert.equal(err.sdkMessage, 'Cannot move call without a resourceId.');
+          }
+        });
+
+        it('should postEvent on moveFrom ', async () => {
+          await meeting.moveFrom('resourceId');
+
+          assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
+        });
+
+        it('should call `MeetingUtil.joinMeetingOptions` with resourceId', async () => {
+          sinon.spy(MeetingUtil, 'joinMeetingOptions');
+          await meeting.moveFrom('resourceId');
+
+          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting);
+          assert.calledWith(MeetingUtil.leaveMeeting, meeting, {
+            resourceId: 'resourceId',
+            correlationId: meeting.correlationId,
+            moveMeeting: true
+          });
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.MOVE_FROM_SUCCESS,
+          );
+        });
+
+        it('should throw an error if moveFrom call fails', async () => {
+          MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveFrom('resourceId');
+          }
+          catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MOVE_FROM_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: sinon.match.any,
+                stack: sinon.match.any
+              }
+            );
+          }
+        });
+      });
     });
 
     describe('Public Event Triggers', () => {