@webex/plugin-meetings 3.0.0-beta.21 → 3.0.0-beta.211

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

@@ -0,0 +1,181 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MockWebex from '@webex/test-helper-mock-webex';
+import {_MEETING_ID_} from '@webex/plugin-meetings/src/constants';
+
+import MeetingInfo from '@webex/plugin-meetings/src/meeting-info/index';
+import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/util';
+import MeetingInfoRequest from '@webex/plugin-meetings/src/meeting-info/request';
+
+const flushPromises = () => new Promise(setImmediate);
+
+describe('plugin-meetings', () => {
+  let webex;
+  let meetingInfo = null;
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('Meeting Info V1', () => {
+    beforeEach(() => {
+      webex = new MockWebex({});
+
+      meetingInfo = new MeetingInfo(webex);
+    });
+
+    describe('#fetchMeetingInfo', () => {
+      it('should send ca events if meetingId present', async () => {
+        const body = {meetingKey: '1234323'};
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .resolves({type: 'MEETING_ID', destination: '123456'});
+        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+
+        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null, {
+          meetingId: 'meetingId',
+        });
+
+        const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+        assert.deepEqual(submitInternalEventCalls[0].args[0], {
+          name: 'internal.client.meetinginfo.request',
+        });
+        assert.deepEqual(submitInternalEventCalls[1].args[0], {
+          name: 'internal.client.meetinginfo.response',
+        });
+      });
+
+      it('should not send ca events if meetingId not present', async () => {
+        const body = {meetingKey: '1234323'};
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .resolves({type: 'MEETING_ID', destination: '123456'});
+        sinon.stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo').returns(Promise.resolve(body));
+
+        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, null);
+
+        assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
+      });
+
+      it('should send ca events when fails and if meetingId present', async () => {
+        const reject = {
+          statusCode: 403,
+          body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
+          url: 'http://api-url.com',
+        };
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .returns(Promise.resolve({type: 'MEETING_ID', destination: '123456'}));
+        sinon
+          .stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo')
+          .returns(Promise.reject(reject));
+
+        try {
+          await meetingInfo.fetchMeetingInfo(
+            '1234323',
+            _MEETING_ID_,
+            null,
+            null,
+            null,
+            null,
+            null,
+            {
+              meetingId: 'meetingId',
+            }
+          );
+        } catch (err) {
+          const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+          assert.deepEqual(submitInternalEventCalls[0].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: 'http://api-url.com',
+              },
+            },
+            options: {
+              meetingId: 'meetingId',
+              rawError: err,
+            },
+          });
+        }
+      });
+
+      it('should send ca events when in the retry as well if meetingId present', async () => {
+        const reject = {
+          statusCode: 403,
+          body: {message: 'msg', code: 403102, data: {meetingInfo: {}}},
+          url: 'http://api-url.com',
+        };
+
+        sinon
+          .stub(MeetingInfoUtil, 'generateOptions')
+          .resolves({type: 'MEETING_LINK', destination: '123456'});
+        const requestStub = sinon
+          .stub(MeetingInfoRequest.prototype, 'fetchMeetingInfo')
+          .rejects(reject);
+
+        try {
+          await meetingInfo.fetchMeetingInfo(
+            '1234323',
+            _MEETING_ID_,
+            null,
+            null,
+            null,
+            null,
+            null,
+            {
+              meetingId: 'meetingId',
+            }
+          );
+          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+        } catch (err) {
+          let submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+          assert.deepEqual(submitInternalEventCalls[0].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: 'http://api-url.com',
+              },
+            },
+            options: {
+              meetingId: 'meetingId',
+              rawError: err,
+            },
+          });
+
+          assert.deepEqual(submitInternalEventCalls[1].args[0], {
+            name: 'internal.client.meetinginfo.response',
+          });
+
+          assert.deepEqual(submitInternalEventCalls[2].args[0], {
+            name: 'internal.client.meetinginfo.request',
+          });
+
+          requestStub.resolves({});
+
+          await flushPromises();
+
+          submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+
+          assert.deepEqual(submitInternalEventCalls[3].args[0], {
+            name: 'internal.client.meetinginfo.response',
+          });
+        }
+      });
+    });
+  });
+});

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -13,6 +13,7 @@ import {
   _CONVERSATION_URL_,
   _SIP_URI_,
   WBXAPPAPI_SERVICE,
+  _LOCUS_ID_,
 } from '@webex/plugin-meetings/src/constants';
 
 import Meetings from '@webex/plugin-meetings/src/meetings';
@@ -20,10 +21,12 @@ import MeetingInfo, {
   MeetingInfoV2PasswordError,
   MeetingInfoV2CaptchaError,
   MeetingInfoV2AdhocMeetingError,
+  MeetingInfoV2PolicyError,
 } from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+import {forEach} from 'lodash';
 
 describe('plugin-meetings', () => {
   const conversation = {
@@ -120,7 +123,7 @@ describe('plugin-meetings', () => {
         MeetingInfoUtil.getRequestBody.restore();
       });
 
-      it('should fetch meeting info for the personal meeting room  type', async () => {
+      it('should fetch meeting info for the personal meeting room type', async () => {
         const body = {meetingKey: '1234323'};
         const requestResponse = {statusCode: 200, body};
 
@@ -211,6 +214,87 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should fetch meeting info with provided installedOrgID', async () => {
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+        const installedOrgID = '123456';
+
+        webex.request.resolves(requestResponse);
+
+        const result = await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, installedOrgID);
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: WBXAPPAPI_SERVICE,
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            supportCountryList: true,
+            meetingKey: '1234323',
+            installedOrgID,
+          },
+        });
+        assert.deepEqual(result, requestResponse);
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
+        );
+      });
+
+      it('should fetch meeting info with provided locusId', async () => {
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+        const locusId = 'eccd5c1b-d42d-35e3-a1b9-3021030a6d84';
+
+        webex.request.resolves(requestResponse);
+
+        const result = await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, locusId);
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: WBXAPPAPI_SERVICE,
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            supportCountryList: true,
+            meetingKey: '1234323',
+            locusId,
+          },
+        });
+        assert.deepEqual(result, requestResponse);
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
+        );
+      });
+
+      it('should fetch meeting info with provided extraParams', async () => {
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+        const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
+
+        webex.request.resolves(requestResponse);
+
+        const result = await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, null, null, null, null, extraParams);
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: WBXAPPAPI_SERVICE,
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            supportCountryList: true,
+            meetingKey: '1234323',
+            ...extraParams,
+          },
+        });
+        assert.deepEqual(result, requestResponse);
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
+        );
+      });
+
       it('create adhoc meeting when conversationUrl passed with enableAdhocMeetings toggle', async () => {
         sinon.stub(meetingInfo, 'createAdhocSpaceMeeting').returns(Promise.resolve());
         await meetingInfo.fetchMeetingInfo('conversationUrl', _CONVERSATION_URL_);
@@ -220,6 +304,29 @@ describe('plugin-meetings', () => {
         meetingInfo.createAdhocSpaceMeeting.restore();
       });
 
+      it('create adhoc meeting when conversationUrl and installedOrgID passed with enableAdhocMeetings toggle', async () => {
+        sinon.stub(meetingInfo, 'createAdhocSpaceMeeting').returns(Promise.resolve());
+
+        const installedOrgID = '12345'
+
+        await meetingInfo.fetchMeetingInfo(
+          'conversationUrl',
+          _CONVERSATION_URL_,
+          null,
+          null,
+          installedOrgID
+        );
+
+        assert.calledOnceWithExactly(
+          meetingInfo.createAdhocSpaceMeeting,
+          'conversationUrl',
+          installedOrgID
+        );
+        assert.notCalled(webex.request);
+        meetingInfo.createAdhocSpaceMeeting.restore();
+      });
+
+
       it('should not call createAdhocSpaceMeeting if enableAdhocMeetings toggle is off', async () => {
         webex.config.meetings.experimental.enableAdhocMeetings = false;
         sinon.stub(meetingInfo, 'createAdhocSpaceMeeting').returns(Promise.resolve());
@@ -245,7 +352,7 @@ describe('plugin-meetings', () => {
       it('should throw an error MeetingInfoV2AdhocMeetingError if not able to start adhoc meeting for a conversation', async () => {
         webex.config.meetings.experimental.enableAdhocMeetings = true;
 
-        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 400000}});
+        webex.request = sinon.stub().rejects({stack: 'a stack', message: 'a message', statusCode: 403, body: {code: 400000}});
         try {
           await meetingInfo.createAdhocSpaceMeeting('conversationUrl');
         } catch (err) {
@@ -255,6 +362,160 @@ describe('plugin-meetings', () => {
             'Failed starting the adhoc meeting, Please contact support team , code=400000'
           );
           assert.equal(err.wbxAppApiCode, 400000);
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADHOC_MEETING_FAILURE,
+            {reason: 'a message', stack: 'a stack'}
+          );
+        }
+      });
+
+      forEach(
+        [
+          {errorCode: 403049},
+          {errorCode: 403104},
+          {errorCode: 403103},
+          {errorCode: 403048},
+          {errorCode: 403102},
+          {errorCode: 403101},
+        ],
+        ({errorCode}) => {
+          it(`should throw a MeetingInfoV2PolicyError for error code ${errorCode}`, async () => {
+            const message = 'a message';
+            const meetingInfoData = 'meeting info';
+
+            webex.request = sinon.stub().rejects({
+              statusCode: 403,
+              body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+              url: 'http://api-url.com',
+            });
+            try {
+              await meetingInfo.fetchMeetingInfo(
+                '1234323',
+                _MEETING_ID_,
+                'abc',
+                {
+                  id: '999',
+                  code: 'aabbcc11',
+                },
+                null,
+                null,
+                {},
+                {meetingId: 'meeting-id'}
+              );
+              assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+            } catch (err) {
+              assert(webex.internal.newMetrics.submitClientEvent.calledOnce);
+              const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+              assert.deepEqual(submitInternalEventCalls[0].args[0], {
+                name: 'internal.client.meetinginfo.request',
+              });
+              assert.deepEqual(submitInternalEventCalls[1].args[0], {
+                name: 'internal.client.meetinginfo.response',
+              });
+              assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+                name: 'client.meetinginfo.response',
+                payload: {
+                  identifiers: {
+                    meetingLookupUrl: 'http://api-url.com',
+                  },
+                },
+                options: {
+                  meetingId: 'meeting-id',
+                  rawError: {
+                    statusCode: 403,
+                    body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+                    url: 'http://api-url.com',
+                  },
+                },
+              });
+
+              assert.instanceOf(err, MeetingInfoV2PolicyError);
+              assert.deepEqual(err.message, `${message}, code=${errorCode}`);
+              assert.equal(err.wbxAppApiCode, errorCode);
+              assert.deepEqual(err.meetingInfo, meetingInfoData);
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.MEETING_INFO_POLICY_ERROR,
+                {code: errorCode}
+              );
+            }
+          });
+        }
+      );
+
+      it('should send internal CA metric if meetingId is provided', async () => {
+        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323'}};
+        const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
+
+        webex.request.resolves(requestResponse);
+
+        const result = await meetingInfo.fetchMeetingInfo(
+          '1234323',
+          _MEETING_ID_,
+          null,
+          null,
+          null,
+          null,
+          extraParams,
+          {meetingId: 'meetingId'}
+        );
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: WBXAPPAPI_SERVICE,
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            supportCountryList: true,
+            meetingKey: '1234323',
+            ...extraParams,
+          },
+        });
+        assert.deepEqual(result, requestResponse);
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
+        );
+
+        const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
+        assert.deepEqual(submitInternalEventCalls[0].args[0], {
+          name: 'internal.client.meetinginfo.request',
+        });
+        assert.deepEqual(submitInternalEventCalls[1].args[0], {
+          name: 'internal.client.meetinginfo.response',
+        });
+      });
+
+      it('should not send CA metric if meetingId is not provided', async () => {
+        const message = 'a message';
+        const meetingInfoData = 'meeting info';
+
+        webex.request = sinon.stub().rejects({
+          statusCode: 403,
+          body: {message, code: 403102, data: {meetingInfo: meetingInfoData}},
+          url: 'http://api-url.com',
+        });
+        try {
+          await meetingInfo.fetchMeetingInfo(
+            '1234323',
+            _MEETING_ID_,
+            'abc',
+            {
+              id: '999',
+              code: 'aabbcc11',
+            },
+            null,
+            null,
+            undefined
+          );
+          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+        } catch (err) {
+          assert.notCalled(webex.internal.newMetrics.submitClientEvent);
+          assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
         }
       });
 
@@ -328,11 +589,51 @@ describe('plugin-meetings', () => {
           await runTest(423001, false);
         });
       });
+
+      it('should throw an error and not fetch with an "empty" body', async () => {
+        const body = {supportHostKey: 'foo', supportCountryList: 'bar'};
+        const requestResponse = {statusCode: 200, body};
+
+        sinon
+          .stub(MeetingInfoUtil, 'getDestinationType')
+          .returns(Promise.resolve({type: _LOCUS_ID_, destination: '123456'}));
+        sinon.stub(MeetingInfoUtil, 'getRequestBody').returns(Promise.resolve(body));
+        webex.request.resolves(requestResponse);
+
+        try {
+          await meetingInfo.fetchMeetingInfo({
+            type: _LOCUS_ID_,
+          });
+          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+        } catch (err) {
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_FAILURE,
+            {
+              reason: 'Not enough information to fetch meeting info',
+              destinationType: _LOCUS_ID_,
+              webExMeetingId: undefined,
+              sipUri: undefined,
+            }
+          );
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_FAILURE
+          );
+          assert.deepEqual(err.message, 'Not enough information to fetch meeting info');
+        }
+
+        MeetingInfoUtil.getDestinationType.restore();
+        MeetingInfoUtil.getRequestBody.restore();
+      });
     });
 
     describe('createAdhocSpaceMeeting', () => {
-      it('Make a request to /instantSpace when conversationUrl', async () => {
-        const conversationUrl = 'https://conversationUrl/xxx';
+      const conversationUrl = 'https://conversationUrl/xxx';
+      const installedOrgID = '12345';
+
+      const setup = () => {
         const invitee = [];
 
         invitee.push({
@@ -345,7 +646,43 @@ describe('plugin-meetings', () => {
           ciUserUuid: conversation.participants.items[1].entryUUID,
         });
 
-        await meetingInfo.createAdhocSpaceMeeting(conversationUrl);
+        return {invitee}
+      }
+
+      it('Make a request to /spaceInstant when conversationUrl', async () => {
+        const {invitee} = setup();
+
+        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl);
+
+        assert.calledWith(
+          webex.internal.conversation.get,
+          {url: conversationUrl},
+          {includeParticipants: true, disableTransform: true}
+        );
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          uri: 'https://go.webex.com/wbxappapi/v2/meetings/spaceInstant',
+          body: {
+            title: conversation.displayName,
+            spaceUrl: conversation.url,
+            keyUrl: conversation.encryptionKeyUrl,
+            kroUrl: conversation.kmsResourceObjectUrl,
+            invitees: invitee,
+          },
+        });
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
+        assert.deepEqual(result, {
+          body: {},
+          statusCode: 200
+        });
+      });
+
+      it('Make a request to /spaceInstant when conversationUrl with installed org ID', async () => {
+        const {invitee} = setup();
+
+        await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
 
         assert.calledWith(
           webex.internal.conversation.get,
@@ -362,11 +699,52 @@ describe('plugin-meetings', () => {
             keyUrl: conversation.encryptionKeyUrl,
             kroUrl: conversation.kmsResourceObjectUrl,
             invitees: invitee,
+            installedOrgID,
           },
         });
         assert(Metrics.sendBehavioralMetric.calledOnce);
         assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
       });
+
+
+      forEach(
+        [
+          {errorCode: 403049},
+          {errorCode: 403104},
+          {errorCode: 403103},
+          {errorCode: 403048},
+          {errorCode: 403102},
+          {errorCode: 403101},
+        ],
+        ({errorCode}) => {
+          it(`should throw a MeetingInfoV2PolicyError for error code ${errorCode}`, async () => {
+            const message = 'a message';
+            const meetingInfoData = 'meeting info';
+
+            webex.request = sinon.stub().rejects({
+              statusCode: 403,
+              body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+            });
+            try {
+              await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
+              assert.fail('createAdhocSpaceMeeting should have thrown, but has not done that');
+            } catch (err) {
+              assert.instanceOf(err, MeetingInfoV2PolicyError);
+              assert.deepEqual(err.message, `${message}, code=${errorCode}`);
+              assert.equal(err.wbxAppApiCode, errorCode);
+              assert.deepEqual(err.meetingInfo, meetingInfoData);
+
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.MEETING_INFO_POLICY_ERROR,
+                {code: errorCode}
+              );
+
+            }
+          });
+        }
+      );
     });
   });
 });

package/test/unit/spec/meeting-info/utilv2.js

@@ -150,6 +150,7 @@ describe('plugin-meetings', () => {
     });
 
     describe('#getRequestBody', () => {
+
       it('for _PERSONAL_ROOM_', () => {
         const res = MeetingInfoUtil.getRequestBody({
           type: _PERSONAL_ROOM_,
@@ -219,6 +220,26 @@ describe('plugin-meetings', () => {
           'https://conv-a.wbx2.com/conversation/api/v1/conversations/bfb49280'
         );
       });
+
+      it('allows for extra params to be provided', () => {
+        const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
+
+        const res = MeetingInfoUtil.getRequestBody({
+          type: _CONVERSATION_URL_,
+          destination: 'https://conv-a.wbx2.com/conversation/api/v1/conversations/bfb49281',
+          extraParams,
+        });
+
+        assert.deepEqual(
+          res,
+          {
+            conversationUrl: 'https://conv-a.wbx2.com/conversation/api/v1/conversations/bfb49281',
+            supportHostKey: true,
+            supportCountryList: true,
+            ...extraParams,
+          }
+        );
+      });
     });
 
     describe('#getWebexSite', () => {

package/test/unit/spec/meetings/collection.js

@@ -48,5 +48,19 @@ describe('plugin-meetings', () => {
         assert.deepEqual(meetingCollection.getByKey('value', 'test'), {value: 'test', id: uuid1});
       });
     });
+
+    describe('#getActiveBreakoutLocus', () => {
+      beforeEach(() => {
+        meetingCollection.meetings.test = {breakouts: {url: 'url', isActiveBreakout: true}, id: uuid1};
+      });
+      it('return null if empty breakoutUrl', () => {
+        assert.deepEqual(meetingCollection.getActiveBreakoutLocus(), null);
+      });
+
+      it('should get the meeting which joined breakout by breakoutUrl', () => {
+        assert.deepEqual(meetingCollection.getActiveBreakoutLocus('url'), {
+          breakouts: {url: 'url', isActiveBreakout: true}, id: uuid1});
+      });
+    });
   });
 });