@webex/plugin-meetings 3.5.0-wxcc.1 → 3.6.0

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

@@ -5,7 +5,6 @@ import 'jsdom-global/register';
 import {cloneDeep, forEach, isEqual, isUndefined} from 'lodash';
 import sinon from 'sinon';
 import * as InternalMediaCoreModule from '@webex/internal-media-core';
-import * as RtcMetricsModule from '@webex/plugin-meetings/src/rtcMetrics';
 import * as RemoteMediaManagerModule from '@webex/plugin-meetings/src/multistream/remoteMediaManager';
 import StateMachine from 'javascript-state-machine';
 import uuid from 'uuid';
@@ -307,7 +306,7 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.resource, uuid2);
           assert.equal(meeting.deviceUrl, uuid3);
           assert.equal(meeting.correlationId, correlationId);
-          assert.deepEqual(meeting.callStateForMetrics, {correlationId});
+          assert.deepEqual(meeting.callStateForMetrics, {correlationId, sessionCorrelationId: ''});
           assert.deepEqual(meeting.meetingInfo, {});
           assert.instanceOf(meeting.members, Members);
           assert.calledOnceWithExactly(
@@ -376,7 +375,7 @@ describe('plugin-meetings', () => {
             }
           );
           assert.equal(newMeeting.correlationId, newMeeting.id);
-          assert.deepEqual(newMeeting.callStateForMetrics, {correlationId: newMeeting.id});
+          assert.deepEqual(newMeeting.callStateForMetrics, {correlationId: newMeeting.id, sessionCorrelationId: ''});
         });
 
         it('correlationId can be provided in callStateForMetrics', () => {
@@ -403,6 +402,37 @@ describe('plugin-meetings', () => {
             correlationId: uuid4,
             joinTrigger: 'fake-join-trigger',
             loginType: 'fake-login-type',
+            sessionCorrelationId: '',
+          });
+        });
+
+        it('sessionCorrelationId can be provided in callStateForMetrics', () => {
+          const newMeeting = new Meeting(
+            {
+              userId: uuid1,
+              resource: uuid2,
+              deviceUrl: uuid3,
+              locus: {url: url1},
+              destination: testDestination,
+              destinationType: DESTINATION_TYPE.MEETING_ID,
+              callStateForMetrics: {
+                correlationId: uuid4,
+                sessionCorrelationId: uuid1,
+                joinTrigger: 'fake-join-trigger',
+                loginType: 'fake-login-type',
+              },
+            },
+            {
+              parent: webex,
+            }
+          );
+          assert.exists(newMeeting.sessionCorrelationId);
+          assert.equal(newMeeting.sessionCorrelationId, uuid1);
+          assert.deepEqual(newMeeting.callStateForMetrics, {
+            correlationId: uuid4,
+            sessionCorrelationId: uuid1,
+            joinTrigger: 'fake-join-trigger',
+            loginType: 'fake-login-type',
           });
         });
 
@@ -1611,7 +1641,6 @@ describe('plugin-meetings', () => {
 
             assert.calledOnce(MeetingUtil.joinMeeting);
             assert.calledOnce(webex.internal.device.meetingStarted);
-            assert.calledOnce(meeting.setLocus);
             assert.equal(result, joinMeetingResult);
             assert.calledWith(webex.internal.llm.on, 'online', meeting.handleLLMOnline);
           });
@@ -2456,8 +2485,8 @@ describe('plugin-meetings', () => {
         });
 
         it('should create rtcMetrics and pass them to Media.createMediaConnection()', async () => {
-          const fakeRtcMetrics = {id: 'fake rtc metrics object'};
-          const rtcMetricsCtor = sinon.stub(RtcMetricsModule, 'default').returns(fakeRtcMetrics);
+          const setIntervalOriginal = window.setInterval;
+          window.setInterval = sinon.stub().returns(1);
 
           // setup the minimum mocks required for multistream connection
           fakeMediaConnection.createSendSlot = sinon.stub().returns({
@@ -2478,8 +2507,6 @@ describe('plugin-meetings', () => {
             mediaSettings: {},
           });
 
-          assert.calledOnceWithExactly(rtcMetricsCtor, webex, meeting.id, meeting.correlationId);
-
           // check that rtcMetrics was passed to Media.createMediaConnection
           assert.calledOnce(Media.createMediaConnection);
           assert.calledWith(
@@ -2487,10 +2514,10 @@ describe('plugin-meetings', () => {
             true,
             meeting.getMediaConnectionDebugId(),
             meeting.id,
-            sinon.match({
-              rtcMetrics: fakeRtcMetrics,
-            })
+            sinon.match.hasNested('rtcMetrics.webex', webex)
           );
+
+          window.setInterval = setIntervalOriginal;
         });
 
         it('should pass the turn server info to the peer connection', async () => {
@@ -3677,6 +3704,7 @@ describe('plugin-meetings', () => {
                   credential: 'turn password',
                 },
               ],
+              iceCandidatesTimeout: meeting.config.iceCandidatesGatheringTimeout,
               skipInactiveTransceivers: false,
               requireH264: true,
               sdpMunging: {
@@ -3761,11 +3789,16 @@ describe('plugin-meetings', () => {
             // that's being tested in these tests)
             meeting.webex.meetings.registered = true;
             meeting.webex.internal.device.config = {};
-            sinon.stub(MeetingUtil, 'joinMeeting').resolves({
+            sinon.stub(MeetingUtil, 'parseLocusJoin').returns({
               id: 'fake locus from mocked join request',
               locusUrl: 'fake locus url',
               mediaId: 'fake media id',
-            });
+            })
+            sinon.stub(meeting.meetingRequest, 'joinMeeting').resolves({
+              headers: {
+                trackingid: 'fake tracking id',
+              }
+            })
             await meeting.join({enableMultistream: isMultistream});
           });
 
@@ -6927,33 +6960,36 @@ describe('plugin-meetings', () => {
       describe('#setCorrelationId', () => {
         it('should set the correlationId and return undefined', () => {
           assert.equal(meeting.correlationId, correlationId);
-          assert.deepEqual(meeting.callStateForMetrics, {correlationId});
+          assert.deepEqual(meeting.callStateForMetrics, {correlationId, sessionCorrelationId: ''});
           meeting.setCorrelationId(uuid1);
           assert.equal(meeting.correlationId, uuid1);
-          assert.deepEqual(meeting.callStateForMetrics, {correlationId: uuid1});
+          assert.deepEqual(meeting.callStateForMetrics, {correlationId: uuid1, sessionCorrelationId: ''});
         });
       });
 
       describe('#updateCallStateForMetrics', () => {
         it('should update the callState, overriding existing values', () => {
-          assert.deepEqual(meeting.callStateForMetrics, {correlationId});
+          assert.deepEqual(meeting.callStateForMetrics, {correlationId, sessionCorrelationId: ''});
           meeting.updateCallStateForMetrics({
             correlationId: uuid1,
+            sessionCorrelationId: uuid3,
             joinTrigger: 'jt',
             loginType: 'lt',
           });
           assert.deepEqual(meeting.callStateForMetrics, {
             correlationId: uuid1,
+            sessionCorrelationId: uuid3,
             joinTrigger: 'jt',
             loginType: 'lt',
           });
         });
 
         it('should update the callState, keeping non-supplied values', () => {
-          assert.deepEqual(meeting.callStateForMetrics, {correlationId});
+          assert.deepEqual(meeting.callStateForMetrics, {correlationId, sessionCorrelationId: ''});
           meeting.updateCallStateForMetrics({joinTrigger: 'jt', loginType: 'lt'});
           assert.deepEqual(meeting.callStateForMetrics, {
             correlationId,
+            sessionCorrelationId: '',
             joinTrigger: 'jt',
             loginType: 'lt',
           });
@@ -9837,6 +9873,11 @@ describe('plugin-meetings', () => {
               requiredDisplayHints: [],
               requiredPolicies: [SELF_POLICY.SUPPORT_ANNOTATION],
             },
+            {
+              actionName: 'canPollingAndQA',
+              requiredDisplayHints: [],
+              requiredPolicies: [SELF_POLICY.SUPPORT_POLLING_AND_QA],
+            },
           ],
           ({
             actionName,

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

@@ -378,24 +378,36 @@ describe('plugin-meetings', () => {
     });
 
     describe('joinMeeting', () => {
-      it('#Should call `meetingRequest.joinMeeting', async () => {
-        const meeting = {
+      const joinMeetingResponse = {
+        body: {
+          mediaConnections: [],
+          locus: {
+            url: 'differentLocusUrl',
+            self: {
+              id: 'selfId',
+            },
+          },
+        },
+        headers: {
+          trackingid: 'trackingId',
+        },
+      };
+      let meeting;
+
+      beforeEach(() => {
+        meeting = {
           meetingJoinUrl: 'meetingJoinUrl',
           locusUrl: 'locusUrl',
           meetingRequest: {
             joinMeeting: sinon.stub().returns(
-              Promise.resolve({
-                body: {mediaConnections: 'mediaConnections'},
-                headers: {
-                  trackingid: 'trackingId',
-                },
-              })
-            ),
+              Promise.resolve(joinMeetingResponse)),
           },
           getWebexObject: sinon.stub().returns(webex),
+          setLocus: sinon.stub(),
         };
+      });
 
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
+      it('#Should call `meetingRequest.joinMeeting', async () => {
         await MeetingUtil.joinMeeting(meeting, {
           reachability: 'reachability',
           roapMessage: 'roapMessage',
@@ -409,6 +421,10 @@ describe('plugin-meetings', () => {
         assert.equal(parameter.reachability, 'reachability');
         assert.equal(parameter.roapMessage, 'roapMessage');
 
+        assert.calledOnce(meeting.setLocus)
+        const setLocusParameter = meeting.setLocus.getCall(0).args[0];
+        assert.deepEqual(setLocusParameter, MeetingUtil.parseLocusJoin(joinMeetingResponse))
+
         assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
           name: 'client.locus.join.request',
           options: {meetingId: meeting.id},
@@ -424,21 +440,12 @@ describe('plugin-meetings', () => {
           },
           options: {
             meetingId: meeting.id,
-            mediaConnections: 'mediaConnections',
+            mediaConnections: [],
           },
         });
-        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
-        const meeting = {
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
-        };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {
           breakoutsSupported: true,
         });
@@ -447,18 +454,9 @@ describe('plugin-meetings', () => {
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.breakoutsSupported, true);
-        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with liveAnnotationSupported=true when passed in as true', async () => {
-        const meeting = {
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
-        };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {
           liveAnnotationSupported: true,
         });
@@ -467,18 +465,9 @@ describe('plugin-meetings', () => {
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.liveAnnotationSupported, true);
-        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with locale=en_UK, deviceCapabilities=["TEST"] when they are passed in as those values', async () => {
-        const meeting = {
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
-        };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {
           locale: 'en_UK',
           deviceCapabilities: ['TEST'],
@@ -489,21 +478,10 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.locale, 'en_UK');
         assert.deepEqual(parameter.deviceCapabilities, ['TEST']);
-        parseLocusJoinSpy.restore();
       });
 
       it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
-        const meeting = {
-          isMultistream: true,
-          meetingJoinUrl: 'meetingJoinUrl',
-          locusUrl: 'locusUrl',
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
-        };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
+        meeting.isMultistream = true;
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
@@ -511,40 +489,22 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
         assert.equal(parameter.preferTranscoding, false);
-        parseLocusJoinSpy.restore();
       });
 
       it('#Should fallback sipUrl if meetingJoinUrl does not exists', async () => {
-        const meeting = {
-          sipUri: 'sipUri',
-          locusUrl: 'locusUrl',
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
-        };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
+        meeting.meetingJoinUrl = undefined;
+        meeting.sipUri = 'sipUri';
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.inviteeAddress, 'sipUri');
-        parseLocusJoinSpy.restore();
       });
 
       it('#Should fallback to meetingNumber if meetingJoinUrl/sipUrl  does not exists', async () => {
-        const meeting = {
-          meetingNumber: 'meetingNumber',
-          locusUrl: 'locusUrl',
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
-        };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
+        meeting.meetingJoinUrl = undefined;
+        meeting.meetingNumber = 'meetingNumber';
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
@@ -552,28 +512,18 @@ describe('plugin-meetings', () => {
 
         assert.isUndefined(parameter.inviteeAddress);
         assert.equal(parameter.meetingNumber, 'meetingNumber');
-        parseLocusJoinSpy.restore();
       });
 
       it('should pass in the locusClusterUrl from meetingInfo', async () => {
-        const meeting = {
-          meetingInfo: {
-            locusClusterUrl: 'locusClusterUrl',
-          },
-          meetingRequest: {
-            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
-          },
-          getWebexObject: sinon.stub().returns(webex),
+        meeting.meetingInfo = {
+          locusClusterUrl: 'locusClusterUrl',
         };
-
-        const parseLocusJoinSpy = sinon.stub(MeetingUtil, 'parseLocusJoin');
         await MeetingUtil.joinMeeting(meeting, {});
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.locusClusterUrl, 'locusClusterUrl');
-        parseLocusJoinSpy.restore();
       });
     });
 

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

@@ -8,6 +8,7 @@ import {Crypto} from '@peculiar/webcrypto';
 global.crypto = new Crypto();
 
 import Device from '@webex/internal-plugin-device';
+import {CatalogDetails} from '@webex/internal-plugin-device';
 import Mercury from '@webex/internal-plugin-mercury';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
@@ -128,6 +129,11 @@ describe('plugin-meetings', () => {
 
       Object.assign(webex, {
         logger,
+        people: {
+          _getMe: sinon.stub().resolves({
+            type: 'validuser', 
+          }),
+        }
       });
 
       startReachabilityStub = sinon.stub(webex.meetings, 'startReachability').resolves();
@@ -196,6 +202,43 @@ describe('plugin-meetings', () => {
       assert.calledOnce(MeetingsUtil.checkH264Support);
     });
 
+    describe('#getBasicMeetingInformation', () => {
+      beforeEach(() => {
+        sinon.stub(MeetingUtil, 'cleanUp');
+      });
+
+      it('returns correct meeting information', async () => {
+        const meeting = await webex.meetings.createMeeting('test', 'test');
+
+        const meetingIds = {
+          meetingId: meeting.id,
+          correlationId: meeting.correlationId,
+        };
+
+        // before meeting is destroyed - it should return information from the meetingCollection
+        assert.equal(
+          webex.meetings.getBasicMeetingInformation(meetingIds.meetingId).id,
+          meetingIds.meetingId
+        );
+        assert.equal(
+          webex.meetings.getBasicMeetingInformation(meetingIds.meetingId).correlationId,
+          meetingIds.correlationId
+        );
+
+        webex.meetings.destroy(meeting, test1);
+
+        // and it should still return the information after the meeting is destroyed
+        assert.equal(
+          webex.meetings.getBasicMeetingInformation(meetingIds.meetingId).id,
+          meetingIds.meetingId
+        );
+        assert.equal(
+          webex.meetings.getBasicMeetingInformation(meetingIds.meetingId).correlationId,
+          meetingIds.correlationId
+        );
+      });
+    });
+
     describe('#startReachability', () => {
       let gatherReachabilitySpy;
       let fakeResult = {id: 'fake-result'};
@@ -346,12 +389,21 @@ describe('plugin-meetings', () => {
           webex.canAuthorize = true;
           webex.meetings.registered = false;
           await webex.meetings.register();
-          assert.called(webex.internal.device.register);
+          assert.calledOnceWithExactly(webex.internal.device.register, undefined);
           assert.called(webex.internal.services.getMeetingPreferences);
           assert.called(webex.internal.services.fetchClientRegionInfo);
           assert.called(webex.internal.mercury.connect);
           assert.isTrue(webex.meetings.registered);
         });
+
+        it('passes on the device registration options', async () => {
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+          await webex.meetings.register({includeDetails: CatalogDetails.features});
+          assert.calledOnceWithExactly(webex.internal.device.register, {
+            includeDetails: CatalogDetails.features,
+          });
+        });
       });
 
       describe('#unregister', () => {
@@ -753,14 +805,16 @@ describe('plugin-meetings', () => {
 
         const FAKE_USE_RANDOM_DELAY = true;
         const correlationId = 'my-correlationId';
+        const sessionCorrelationId = 'my-session-correlationId';
         const callStateForMetrics = {
+          sessionCorrelationId: 'my-session-correlationId2',
           correlationId: 'my-correlationId2',
           joinTrigger: 'my-join-trigger',
           loginType: 'my-login-type',
         };
 
-        it('should call setCallStateForMetrics on any pre-existing meeting', async () => {
-          const fakeMeeting = {setCallStateForMetrics: sinon.mock()};
+        it('should call updateCallStateForMetrics on any pre-existing meeting', async () => {
+          const fakeMeeting = {updateCallStateForMetrics: sinon.mock()};
           webex.meetings.meetingCollection.getByKey = sinon.stub().returns(fakeMeeting);
           await webex.meetings.create(
             test1,
@@ -769,11 +823,15 @@ describe('plugin-meetings', () => {
             {},
             correlationId,
             true,
-            callStateForMetrics
+            callStateForMetrics,
+            undefined,
+            undefined,
+            sessionCorrelationId
           );
-          assert.calledOnceWithExactly(fakeMeeting.setCallStateForMetrics, {
+          assert.calledOnceWithExactly(fakeMeeting.updateCallStateForMetrics, {
             ...callStateForMetrics,
             correlationId,
+            sessionCorrelationId,
           });
         });
 
@@ -814,13 +872,14 @@ describe('plugin-meetings', () => {
               undefined,
               meetingInfo,
               'meetingLookupURL',
+              sessionCorrelationId,
             ],
             [
               test1,
               test2,
               FAKE_USE_RANDOM_DELAY,
               {},
-              {correlationId},
+              {correlationId, sessionCorrelationId},
               true,
               meetingInfo,
               'meetingLookupURL',
@@ -1719,6 +1778,7 @@ describe('plugin-meetings', () => {
             const expectedMeetingData = {
               correlationId: 'my-correlationId',
               callStateForMetrics: {
+                sessionCorrelationId: '',
                 correlationId: 'my-correlationId',
                 joinTrigger: 'my-join-trigger',
                 loginType: 'my-login-type',
@@ -1812,7 +1872,10 @@ describe('plugin-meetings', () => {
           });
 
           it('creates the meeting avoiding meeting info fetch by passing type as DESTINATION_TYPE.ONE_ON_ONE_CALL', async () => {
-            const meeting = await webex.meetings.createMeeting('test destination', DESTINATION_TYPE.ONE_ON_ONE_CALL);
+            const meeting = await webex.meetings.createMeeting(
+              'test destination',
+              DESTINATION_TYPE.ONE_ON_ONE_CALL
+            );
 
             assert.instanceOf(
               meeting,
@@ -1822,7 +1885,6 @@ describe('plugin-meetings', () => {
 
             assert.notCalled(webex.meetings.meetingInfo.fetchMeetingInfo);
           });
-
         });
 
         describe('rejected MeetingInfo.#fetchMeetingInfo - does not log for known Error types', () => {
@@ -1896,17 +1958,23 @@ describe('plugin-meetings', () => {
           assert.exists(webex.meetings.destroy);
         });
         describe('correctly established meeting', () => {
+          let deleteSpy;
           beforeEach(() => {
-            webex.meetings.meetingCollection.delete = sinon.stub().returns(true);
+            deleteSpy = sinon.spy(webex.meetings.meetingCollection, 'delete');
           });
 
-          it('tests the destroy removal from the collection', async () => {
+          it('tests the destroy removal from the collection and storing basic info in deletedMeetings', async () => {
             const meeting = await webex.meetings.createMeeting('test', 'test');
 
+            const meetingIds = {
+              meetingId: meeting.id,
+              correlationId: meeting.correlationId,
+            };
+
             webex.meetings.destroy(meeting, test1);
 
-            assert.calledOnce(webex.meetings.meetingCollection.delete);
-            assert.calledWith(webex.meetings.meetingCollection.delete, meeting.id);
+            assert.calledOnce(deleteSpy);
+            assert.calledWith(deleteSpy, meeting.id);
             assert.calledWith(
               TriggerProxy.trigger,
               sinon.match.instanceOf(Meetings),
@@ -1920,6 +1988,23 @@ describe('plugin-meetings', () => {
                 reason: test1,
               }
             );
+
+            // check that the meeting is stored in deletedMeetings and removed from meetingCollection
+            assert.equal(webex.meetings.deletedMeetings.get(meeting.id).id, meetingIds.meetingId);
+            assert.equal(
+              webex.meetings.deletedMeetings.get(meeting.id).correlationId,
+              meetingIds.correlationId
+            );
+
+            assert.equal(webex.meetings.meetingCollection.get(meeting.id), undefined);
+
+            // and that getBasicMeetingInformation() still returns the meeting info
+            const deletedMeetingInfo = webex.meetings.getBasicMeetingInformation(
+              meetingIds.meetingId
+            );
+
+            assert.equal(deletedMeetingInfo.id, meetingIds.meetingId);
+            assert.equal(deletedMeetingInfo.correlationId, meetingIds.correlationId);
           });
         });
 
@@ -1976,7 +2061,7 @@ describe('plugin-meetings', () => {
           ]);
         });
 
-        const setup = ({user} = {}) => {
+        const setup = ({me = { type: 'validuser'}, user} = {}) => {
           loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
 
@@ -1989,8 +2074,22 @@ describe('plugin-meetings', () => {
           Object.assign(webex.internal.services, {
             getMeetingPreferences: sinon.stub().returns(Promise.resolve({})),
           });
+
+          Object.assign(webex.people, {
+            _getMe: sinon.stub().returns(Promise.resolve(me)),
+        });
         };
 
+        it('should not call request.getMeetingPreferences if user is a guest', async () => {
+          setup({me: {type: 'appuser'}});
+      
+          await webex.meetings.fetchUserPreferredWebexSite();
+      
+          assert.equal(webex.meetings.preferredWebexSite, '');
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
+          assert.notCalled(webex.internal.services.getMeetingPreferences);
+        });
+
         it('should not fail if UserPreferred info is not fetched ', async () => {
           setup();
 

package/src/rtcMetrics/constants.ts

@@ -1,3 +0,0 @@
-const RTC_METRICS = {APP_ID: 'FFB51ED5-4319-4C55-8303-B1F2FCCDE231'};
-
-export {RTC_METRICS as default};