@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

@@ -13,7 +13,6 @@ import {
   _CONVERSATION_URL_,
   _SIP_URI_,
   WBXAPPAPI_SERVICE,
-  _LOCUS_ID_,
 } from '@webex/plugin-meetings/src/constants';
 
 import Meetings from '@webex/plugin-meetings/src/meetings';
@@ -21,13 +20,10 @@ 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';
-import { request } from 'express';
 
 describe('plugin-meetings', () => {
   const conversation = {
@@ -124,7 +120,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};
 
@@ -215,87 +211,6 @@ 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_);
@@ -305,29 +220,6 @@ 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());
@@ -353,7 +245,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({stack: 'a stack', message: 'a message', statusCode: 403, body: {code: 400000}});
+        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 400000}});
         try {
           await meetingInfo.createAdhocSpaceMeeting('conversationUrl');
         } catch (err) {
@@ -363,305 +255,9 @@ 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, sendCAevents: false},
-          {errorCode: 403049, sendCAevents: true},
-          {errorCode: 403049},
-          {errorCode: 403104, sendCAevents: false},
-          {errorCode: 403104, sendCAevents: true},
-          {errorCode: 403104},
-          {errorCode: 403103, sendCAevents: false},
-          {errorCode: 403103, sendCAevents: true},
-          {errorCode: 403103},
-          {errorCode: 403048, sendCAevents: false},
-          {errorCode: 403048, sendCAevents: true},
-          {errorCode: 403048},
-          {errorCode: 403102, sendCAevents: false},
-          {errorCode: 403102, sendCAevents: true},
-          {errorCode: 403102},
-          {errorCode: 403101, sendCAevents: false},
-          {errorCode: 403101, sendCAevents: true},
-          {errorCode: 403101},
-        ],
-        ({errorCode, sendCAevents}) => {
-          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', sendCAevents}
-              );
-              assert.fail('fetchMeetingInfo should have thrown, but has not done that');
-            } catch (err) {
-              const submitInternalEventCalls = webex.internal.newMetrics.submitInternalEvent.getCalls();
-              const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
-
-              if (sendCAevents) {
-                assert.deepEqual(submitInternalEventCalls[0].args[0], {
-                  name: 'internal.client.meetinginfo.request',
-                });
-
-                assert.deepEqual(submitClientEventCalls[0].args[0], {
-                  name: 'client.meetinginfo.request',
-                  options: {
-                    meetingId: 'meeting-id'
-                  },
-                });
-
-                assert.deepEqual(submitInternalEventCalls[1].args[0], {
-                  name: 'internal.client.meetinginfo.response',
-                });
-                
-                assert.deepEqual(submitClientEventCalls[1].args[0], {
-                  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',
-                    },
-                  },
-                });
-              } else {
-                assert.notCalled(webex.internal.newMetrics.submitClientEvent);
-              }
-
-              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}
-              );
-            }
-          });
-        }
-      );
-
-      forEach(
-        [
-          {meetingId: '123', sendCAevents: true, shouldSendCAevents: true},
-          {sendCAevents: true, shouldSendCAevents: false},
-          {meetingId: '123', sendCAevents: false, shouldSendCAevents: false},
-          {shouldSendCAevents: false},
-          {meetingId: '123', sendCAevents: true, shouldSendCAevents: true, confIdStr: '999'},
-        ],
-        ({meetingId, sendCAevents, shouldSendCAevents, confIdStr}) => {
-          it('should send CA metric if meetingId is provided and send CA events is authorized', async () => {
-            const requestResponse = {statusCode: 200, body: {meetingKey: '1234323', meetingId: '123', confID: '321'}};
-            if (confIdStr) {
-              requestResponse.body.confIdStr = confIdStr;
-            }
-            const extraParams = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'}
-    
-            webex.request.resolves(requestResponse);
-    
-            const result = await meetingInfo.fetchMeetingInfo(
-              '1234323',
-              _MEETING_ID_,
-              null,
-              null,
-              null,
-              null,
-              extraParams,
-              {meetingId, sendCAevents}
-            );
-    
-            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();
-            const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
-
-            if(shouldSendCAevents) {
-              assert.deepEqual(submitInternalEventCalls[0].args[0], {
-                name: 'internal.client.meetinginfo.request',
-              });
-              assert.deepEqual(submitClientEventCalls[0].args[0], {
-                name: 'client.meetinginfo.request',
-                options: {
-                  meetingId,
-                }
-              });
-              
-              assert.deepEqual(submitInternalEventCalls[1].args[0], {
-                name: 'internal.client.meetinginfo.response',
-              });
-              assert.deepEqual(submitClientEventCalls[1].args[0], {
-                name: 'client.meetinginfo.response',
-                payload: {
-                  identifiers: {
-                    meetingLookupUrl: result?.url,
-                  },
-                },
-                options: {
-                  meetingId,
-                  globalMeetingId: requestResponse.body?.meetingId,
-                  webexConferenceIdStr: confIdStr ? requestResponse.body?.confIdStr : requestResponse.body?.confID,
-                }
-              });
-            } else {
-              assert.notCalled(webex.internal.newMetrics.submitClientEvent);
-              assert.notCalled(webex.internal.newMetrics.submitInternalEvent);
-            }
-          })
-        }
-      )
-
-      it('should send CA metric if meetingId is provided and send CA events is authorized', async () => {
-        const requestResponse = {statusCode: 200, body: {meetingKey: '1234323', confID: '123', meetingId: '321'}};
-        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', sendCAevents: true}
-        );
-
-        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();
-        const submitClientEventCalls = webex.internal.newMetrics.submitClientEvent.getCalls();
-        
-        assert.deepEqual(submitInternalEventCalls[0].args[0], {
-          name: 'internal.client.meetinginfo.request',
-        });
-        assert.deepEqual(submitClientEventCalls[0].args[0], {
-          name: 'client.meetinginfo.request',
-          options: {
-            meetingId: 'meetingId',
-          }
-        });
-        
-        assert.deepEqual(submitInternalEventCalls[1].args[0], {
-          name: 'internal.client.meetinginfo.response',
-        });
-        assert.deepEqual(submitClientEventCalls[1].args[0], {
-          name: 'client.meetinginfo.response',
-          payload: {
-            identifiers: {
-              meetingLookupUrl: result?.url,
-            },
-          },
-          options: {
-            meetingId: 'meetingId',
-            globalMeetingId: requestResponse.body?.meetingId,
-            webexConferenceIdStr: requestResponse.body?.confID,
-          }
-        });
-      });
-
-      forEach(
-        [
-          {sendCAevents: true},
-          {sendCAevents: false},
-        ],
-        ({sendCAevents}) => {
-          it(`should not send CA metric if meetingId is not provided disregarding if sendCAevents is ${sendCAevents}`, 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,
-                {meetingId: undefined, sendCAevents}
-              );
-              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);
-            }
-          });
-        }
-      );
-
       it('should throw MeetingInfoV2PasswordError for 403 response', async () => {
         const FAKE_MEETING_INFO = {blablabla: 'some_fake_meeting_info'};
 
@@ -732,51 +328,11 @@ 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', () => {
-      const conversationUrl = 'https://conversationUrl/xxx';
-      const installedOrgID = '12345';
-
-      const setup = () => {
+      it('Make a request to /instantSpace when conversationUrl', async () => {
+        const conversationUrl = 'https://conversationUrl/xxx';
         const invitee = [];
 
         invitee.push({
@@ -789,18 +345,12 @@ describe('plugin-meetings', () => {
           ciUserUuid: conversation.participants.items[1].entryUUID,
         });
 
-        return {invitee}
-      }
-
-      it('Make a request to /spaceInstant when conversationUrl', async () => {
-        const {invitee} = setup();
-
         webex.request.resolves({
           statusCode: 200,
           body: conversation
         });
 
-        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl,installedOrgID);
+        await meetingInfo.createAdhocSpaceMeeting(conversationUrl);
 
         assert.calledWith(
           webex.request,
@@ -816,83 +366,11 @@ describe('plugin-meetings', () => {
             keyUrl: conversation.encryptionKeyUrl,
             kroUrl: conversation.kmsResourceObjectUrl,
             invitees: invitee,
-            installedOrgID: installedOrgID
-          },
-        });
-        assert.calledOnce(Metrics.sendBehavioralMetric);
-        assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
-        assert.deepEqual(result, {
-          body: conversation,
-          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,
-          {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,
-            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,7 +150,6 @@ describe('plugin-meetings', () => {
     });
 
     describe('#getRequestBody', () => {
-
       it('for _PERSONAL_ROOM_', () => {
         const res = MeetingInfoUtil.getRequestBody({
           type: _PERSONAL_ROOM_,
@@ -220,26 +219,6 @@ 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,31 +48,5 @@ 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});
-      });
-    });
-
-    describe('#getActiveWebrtcMeeting', () => {
-      it('returns the meeting with a webrtc media connection', () => {
-        const activeMeeting = {value: 'test3', id: uuid.v4(), mediaProperties: { webrtcMediaConnection: 'something'}};
-
-        meetingCollection.meetings.test = {value: 'test', id: uuid1, mediaProperties: {}};
-        meetingCollection.meetings.test2 = {value: 'test2', id: uuid2, mediaProperties: {}};
-        meetingCollection.meetings.test3 = activeMeeting;
-
-        assert.equal(meetingCollection.getActiveWebrtcMeeting(), activeMeeting);
-      })
-    })
   });
 });