@webex/plugin-meetings 3.11.0 → 3.12.0

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

@@ -115,6 +115,7 @@ describe('plugin-meetings', () => {
     });
 
     describe('#changeVideoLayout', () => {
+
       const locusUrl = 'locusURL';
       const deviceUrl = 'deviceUrl';
       const layoutType = 'Equal';
@@ -918,4 +919,73 @@ describe('plugin-meetings', () => {
       });
     });
   });
+
+  describe('#fetchDatachannelToken', () => {
+    const locusUrl = 'https://locus.example.com/locus/api/v1/loci/123';
+    const participantId = 'participant-123';
+
+    beforeEach(() => {
+      sinon.restore();
+      locusDeltaRequestSpy = sinon.stub(meetingsRequest, 'locusDeltaRequest');
+    });
+
+    it('sends GET request to regular datachannel token endpoint', async () => {
+      locusDeltaRequestSpy.resolves({body: {}});
+
+      await meetingsRequest.fetchDatachannelToken({
+        locusUrl,
+        requestingParticipantId: participantId,
+        isPracticeSession: false,
+      });
+
+      assert.calledOnceWithExactly(locusDeltaRequestSpy, {
+        method: 'GET',
+        uri: `${locusUrl}/participant/${participantId}/datachannel/token`,
+      });
+    });
+
+    it('sends GET request to practice session datachannel token endpoint', async () => {
+      locusDeltaRequestSpy.resolves({body: {}});
+
+      await meetingsRequest.fetchDatachannelToken({
+        locusUrl,
+        requestingParticipantId: participantId,
+        isPracticeSession: true,
+      });
+
+      assert.calledOnceWithExactly(locusDeltaRequestSpy, {
+        method: 'GET',
+        uri: `${locusUrl}/participant/${participantId}/practiceSession/datachannel/token`,
+      });
+    });
+
+    it('rejects when locusUrl or participantId is missing', async () => {
+      await assert.isRejected(
+        meetingsRequest.fetchDatachannelToken({
+          locusUrl: null,
+          requestingParticipantId: participantId,
+        }),
+        /locusUrl and participantId are required/
+      );
+
+      await assert.isRejected(
+        meetingsRequest.fetchDatachannelToken({
+          locusUrl,
+          requestingParticipantId: null,
+        }),
+        /locusUrl and participantId are required/
+      );
+    });
+
+    it('returns null when locusDeltaRequest fails', async () => {
+      locusDeltaRequestSpy.rejects(new Error('network error'));
+
+      const result = await meetingsRequest.fetchDatachannelToken({
+        locusUrl,
+        requestingParticipantId: participantId,
+      });
+
+      assert.equal(result, null);
+    });
+  });
 });

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

@@ -11,6 +11,7 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import * as BrowserDetectionModule from '@webex/plugin-meetings/src/common/browser-detection';
 import PasswordError from '@webex/plugin-meetings/src/common/errors/password-error';
 import CaptchaError from '@webex/plugin-meetings/src/common/errors/captcha-error';
+import {ServerRoles} from '@webex/plugin-meetings/src/member/types';
 
 describe('plugin-meetings', () => {
   let webex;
@@ -53,16 +54,18 @@ describe('plugin-meetings', () => {
       meeting.unsetPeerConnections = sinon.stub();
       meeting.reconnectionManager = {cleanUp: sinon.stub()};
       meeting.stopKeepAlive = sinon.stub();
-      meeting.updateLLMConnection = sinon.stub();
+      meeting.cleanupLLMConneciton = sinon.stub().resolves();
       meeting.breakouts = {cleanUp: sinon.stub()};
+      meeting.webinar = {cleanUp: sinon.stub()};
       meeting.annotaion = {cleanUp: sinon.stub()};
       meeting.getWebexObject = sinon.stub().returns(webex);
       meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
       meeting.trigger = sinon.stub();
       meeting.webex = webex;
       meeting.webex.internal.newMetrics.callDiagnosticMetrics =
-      meeting.webex.internal.newMetrics.callDiagnosticMetrics || {};
-      meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId = sinon.stub();
+        meeting.webex.internal.newMetrics.callDiagnosticMetrics || {};
+      meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId =
+        sinon.stub();
     });
 
     afterEach(() => {
@@ -83,7 +86,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
-        assert.calledOnce(meeting.updateLLMConnection);
+        assert.calledOnceWithExactly(meeting.cleanupLLMConneciton, {throwOnError: false});
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
@@ -104,7 +107,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
-        assert.notCalled(meeting.updateLLMConnection);
+        assert.notCalled(meeting.cleanupLLMConneciton);
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
@@ -124,7 +127,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
-        assert.notCalled(meeting.updateLLMConnection);
+        assert.notCalled(meeting.cleanupLLMConneciton);
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
@@ -245,7 +248,11 @@ describe('plugin-meetings', () => {
         const response = MeetingUtil.updateLocusFromApiResponse(meeting, originalResponse);
 
         assert.deepEqual(response, originalResponse);
-        assert.calledOnceWithExactly(meeting.locusInfo.handleLocusAPIResponse, meeting, originalResponse.body);
+        assert.calledOnceWithExactly(
+          meeting.locusInfo.handleLocusAPIResponse,
+          meeting,
+          originalResponse.body
+        );
       });
 
       it('should handle locus being missing from the response', () => {
@@ -361,8 +368,8 @@ describe('plugin-meetings', () => {
     describe('remoteUpdateAudioVideo', () => {
       it('#Should call meetingRequest.locusMediaRequest with correct parameters and return the full response', async () => {
         const fakeResponse = {
-          body: { locus: { url: 'locusUrl'}},
-          headers: { },
+          body: {locus: {url: 'locusUrl'}},
+          headers: {},
         };
         const meeting = {
           id: 'meeting-id',
@@ -480,6 +487,11 @@ describe('plugin-meetings', () => {
             identifiers: {
               trackingId: 'trackingId',
             },
+            eventData: {
+              hasMismatchedSocket: false,
+              mercurySocketUrl: '',
+              deviceSocketUrl: 'ws://example.com',
+            },
           },
           options: {
             meetingId: meeting.id,
@@ -649,21 +661,26 @@ describe('plugin-meetings', () => {
       it('should post client event with error when join fails', async () => {
         const joinError = new Error('Join failed');
         meeting.meetingRequest.joinMeeting.rejects(joinError);
-        meeting.meetingInfo = { meetingLookupUrl: 'test-lookup-url' };
+        meeting.meetingInfo = {meetingLookupUrl: 'test-lookup-url'};
 
         try {
           await MeetingUtil.joinMeeting(meeting, {});
           assert.fail('Expected joinMeeting to throw an error');
         } catch (error) {
           assert.equal(error, joinError);
-          
+
           // Verify error client event was submitted
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.locus.join.response',
             payload: {
-              identifiers: { meetingLookupUrl: 'test-lookup-url' },
+              identifiers: {meetingLookupUrl: 'test-lookup-url'},
+              eventData: {
+                hasMismatchedSocket: false,
+                mercurySocketUrl: '',
+                deviceSocketUrl: 'ws://example.com',
+              },
             },
-            options: { meetingId: meeting.id, rawError: joinError },
+            options: {meetingId: meeting.id, rawError: joinError},
           });
         }
       });
@@ -721,7 +738,7 @@ describe('plugin-meetings', () => {
           assert.fail('Expected joinMeetingOptions to throw PasswordError');
         } catch (error) {
           assert.instanceOf(error, PasswordError);
-          
+
           // Verify client event was submitted with error details
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.meetinginfo.response',
@@ -759,7 +776,7 @@ describe('plugin-meetings', () => {
           assert.fail('Expected joinMeetingOptions to throw CaptchaError');
         } catch (error) {
           assert.instanceOf(error, CaptchaError);
-          
+
           // Verify client event was submitted with error details
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.meetinginfo.response',
@@ -921,6 +938,104 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('canAttendeeRequestAiAssistantEnabled', () => {
+      it('returns false when user is a cohost', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled(
+            ['ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED'],
+            [ServerRoles.Cohost]
+          ),
+          false
+        );
+      });
+
+      it('returns false when user is a moderator', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled(
+            ['ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED'],
+            [ServerRoles.Moderator]
+          ),
+          false
+        );
+      });
+
+      it('returns false when user is both cohost and moderator', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled(
+            ['ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED'],
+            [ServerRoles.Cohost, ServerRoles.Moderator]
+          ),
+          false
+        );
+      });
+
+      it('returns true when user is an attendee and display hint is present', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled(
+            ['ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED'],
+            []
+          ),
+          true
+        );
+      });
+
+      it('returns true when user has other roles (not host/cohost) and display hint is present', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled(
+            ['ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED'],
+            ['SomeOtherRole']
+          ),
+          true
+        );
+      });
+
+      it('returns false when user is an attendee but display hint is not present', () => {
+        assert.deepEqual(MeetingUtil.canAttendeeRequestAiAssistantEnabled([], []), false);
+      });
+
+      it('returns false when user is an attendee with other display hints but not the AI assistant one', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled(['SOME_OTHER_HINT', 'ANOTHER_HINT'], []),
+          false
+        );
+      });
+
+      it('returns false when host/cohost even if display hint is not present', () => {
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled([], [ServerRoles.Cohost]),
+          false
+        );
+        assert.deepEqual(
+          MeetingUtil.canAttendeeRequestAiAssistantEnabled([], [ServerRoles.Moderator]),
+          false
+        );
+      });
+    });
+
+    describe('attendeeRequestAiAssistantDeclinedAll', () => {
+      it('returns true when display hint is present', () => {
+        assert.isTrue(
+          MeetingUtil.attendeeRequestAiAssistantDeclinedAll([
+            'ATTENDEE_REQUEST_AI_ASSISTANT_DECLINED_ALL',
+          ])
+        );
+      });
+
+      it('returns false when display hint is not present', () => {
+        assert.isFalse(MeetingUtil.attendeeRequestAiAssistantDeclinedAll([]));
+      });
+
+      it('returns false when display hint is absent among other hints', () => {
+        assert.isFalse(
+          MeetingUtil.attendeeRequestAiAssistantDeclinedAll(['SOME_OTHER_HINT', 'ANOTHER_HINT'])
+        );
+      });
+
+      it('returns false when called with no arguments', () => {
+        assert.isFalse(MeetingUtil.attendeeRequestAiAssistantDeclinedAll());
+      });
+    });
+
     describe('bothLeaveAndEndMeetingAvailable', () => {
       it('works as expected', () => {
         assert.deepEqual(
@@ -939,6 +1054,46 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('requireHostEndMeetingBeforeLeave', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.requireHostEndMeetingBeforeLeave(['REQUIRE_HOST_END_MEETING_BEFORE_LEAVE']),
+          true
+        );
+        assert.deepEqual(
+          MeetingUtil.requireHostEndMeetingBeforeLeave([
+            'LEAVE_TRANSFER_HOST_END_MEETING',
+            'END_MEETING',
+          ]),
+          false
+        );
+        assert.deepEqual(
+          MeetingUtil.requireHostEndMeetingBeforeLeave([
+            'REQUIRE_HOST_END_MEETING_BEFORE_LEAVE',
+            'END_MEETING',
+          ]),
+          true
+        );
+        assert.deepEqual(
+          MeetingUtil.requireHostEndMeetingBeforeLeave([
+            'REQUIRE_HOST_END_MEETING_BEFORE_LEAVE',
+            'LEAVE_MEETING',
+          ]),
+          true
+        );
+        assert.deepEqual(
+          MeetingUtil.requireHostEndMeetingBeforeLeave([
+            'REQUIRE_HOST_END_MEETING_BEFORE_LEAVE',
+            'LEAVE_MEETING',
+            'END_MEETING',
+          ]),
+          true
+        );
+        assert.deepEqual(MeetingUtil.requireHostEndMeetingBeforeLeave(['END_MEETING']), true);
+        assert.deepEqual(MeetingUtil.requireHostEndMeetingBeforeLeave([]), false);
+      });
+    });
+
     describe('canUserLock', () => {
       it('works as expected', () => {
         assert.deepEqual(
@@ -972,15 +1127,18 @@ describe('plugin-meetings', () => {
       {functionName: 'canStartManualCaption', displayHint: 'MANUAL_CAPTION_START'},
       {functionName: 'canStopManualCaption', displayHint: 'MANUAL_CAPTION_STOP'},
 
-      {functionName: 'isLocalRecordingStarted',displayHint:'LOCAL_RECORDING_STATUS_STARTED'},
+      {functionName: 'isLocalRecordingStarted', displayHint: 'LOCAL_RECORDING_STATUS_STARTED'},
       {functionName: 'isLocalRecordingStopped', displayHint: 'LOCAL_RECORDING_STATUS_STOPPED'},
       {functionName: 'isLocalRecordingPaused', displayHint: 'LOCAL_RECORDING_STATUS_PAUSED'},
-      {functionName: 'isLocalStreamingStarted',displayHint:'STREAMING_STATUS_STARTED'},
+      {functionName: 'isLocalStreamingStarted', displayHint: 'STREAMING_STATUS_STARTED'},
       {functionName: 'isLocalStreamingStopped', displayHint: 'STREAMING_STATUS_STOPPED'},
 
       {functionName: 'isManualCaptionActive', displayHint: 'MANUAL_CAPTION_STATUS_ACTIVE'},
 
-      {functionName: 'isSpokenLanguageAutoDetectionEnabled', displayHint: 'SPOKEN_LANGUAGE_AUTO_DETECTION_ENABLED'},
+      {
+        functionName: 'isSpokenLanguageAutoDetectionEnabled',
+        displayHint: 'SPOKEN_LANGUAGE_AUTO_DETECTION_ENABLED',
+      },
 
       {functionName: 'isWebexAssistantActive', displayHint: 'WEBEX_ASSISTANT_STATUS_ACTIVE'},
       {functionName: 'canViewCaptionPanel', displayHint: 'ENABLE_CAPTION_PANEL'},
@@ -1446,11 +1604,9 @@ describe('plugin-meetings', () => {
                 id: 'selfId123',
               },
             },
+            metaData: {id: 'some hash tree metadata'},
             dataSets: [{name: 'dataset1', url: 'http://dataset.com'}],
-            mediaConnections: [
-              {mediaId: 'mediaId456'},
-              {someOtherField: 'value'},
-            ],
+            mediaConnections: [{mediaId: 'mediaId456'}, {someOtherField: 'value'}],
           },
         };
       });
@@ -1466,6 +1622,7 @@ describe('plugin-meetings', () => {
           locusId: '12345',
           selfId: 'selfId123',
           mediaId: 'mediaId456',
+          metadata: {id: 'some hash tree metadata'},
         });
       });
 
@@ -1495,20 +1652,275 @@ describe('plugin-meetings', () => {
           locusUrl: 'https://locus-a.wbx2.com/locus/api/v1/loci/12345',
           locusId: '12345',
           selfId: 'selfId123',
+          metadata: {id: 'some hash tree metadata'},
         });
         assert.isUndefined(result.mediaId);
       });
 
       it('handles mediaConnections without mediaId', () => {
-        response.body.mediaConnections = [
-          {someField: 'value1'},
-          {anotherField: 'value2'},
-        ];
+        response.body.mediaConnections = [{someField: 'value1'}, {anotherField: 'value2'}];
 
         const result = MeetingUtil.parseLocusJoin(response);
 
         assert.isUndefined(result.mediaId);
       });
     });
+
+    describe('#sanitizeWebSocketUrl', () => {
+      it('extracts protocol, host, and pathname from URL', () => {
+        const url = 'wss://example.com:443/mercury/path?token=secret&key=value#fragment';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com:443/mercury/path');
+      });
+
+      it('handles URL without query string or hash', () => {
+        const url = 'wss://example.com/path';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com/path');
+      });
+
+      it('removes authentication from URL', () => {
+        const url = 'wss://user:password@example.com/path?token=secret';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com/path');
+      });
+
+      it('returns empty string for null or undefined', () => {
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl(null), '');
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl(undefined), '');
+      });
+
+      it('returns empty string for non-string input', () => {
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl(123), '');
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl({}), '');
+      });
+
+      it('returns empty string for invalid URL', () => {
+        const result = MeetingUtil.sanitizeWebSocketUrl('not a valid url');
+
+        assert.equal(result, '');
+      });
+
+      it('handles URL without pathname', () => {
+        const url = 'wss://example.com?query=value';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com');
+      });
+    });
+
+    describe('#_urlsPartiallyMatch', () => {
+      it('returns true when URLs match exactly (ignoring query and hash)', () => {
+        const url1 = 'wss://example.com:443/path?token=abc#fragment1';
+        const url2 = 'wss://example.com:443/path?token=xyz#fragment2';
+
+        assert.isTrue(MeetingUtil._urlsPartiallyMatch(url1, url2));
+      });
+
+      it('returns true when one URL is proxied and ends with the other', () => {
+        const url1 = 'wss://other.example.com/somepath/mercury.example.com/v1/path';
+        const url2 = 'wss://mercury.example.com/v1/path';
+
+        assert.isTrue(MeetingUtil._urlsPartiallyMatch(url1, url2));
+      });
+
+      it('returns true when the second URL is proxied', () => {
+        const url1 = 'wss://mercury.example.com/v1/path';
+        const url2 = 'wss://other.example.com/somepath/mercury.example.com/v1/path';
+
+        assert.isTrue(MeetingUtil._urlsPartiallyMatch(url1, url2));
+      });
+
+      it('returns false when hosts differ and no partial match', () => {
+        const url1 = 'wss://example1.com/path';
+        const url2 = 'wss://example2.com/path';
+
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(url1, url2));
+      });
+
+      it('returns false when pathnames differ and no partial match', () => {
+        const url1 = 'wss://example.com/path1';
+        const url2 = 'wss://example.com/path2';
+
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(url1, url2));
+      });
+
+      it('returns false when either URL is null or undefined', () => {
+        const url = 'wss://example.com/path';
+
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(null, url));
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(url, null));
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(undefined, url));
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(url, undefined));
+      });
+
+      it('returns false when both URLs are null', () => {
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(null, null));
+      });
+
+      it('returns false when URL parsing fails', () => {
+        const url1 = 'invalid url';
+        const url2 = 'wss://example.com/path';
+
+        assert.isFalse(MeetingUtil._urlsPartiallyMatch(url1, url2));
+      });
+    });
+
+    describe('#getSocketUrlInfo', () => {
+      it('returns socket URL info when URLs differ', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://mercury.example.com:443/path?token=abc',
+              },
+            },
+            device: {
+              webSocketUrl: 'wss://device.example.com:443/path?token=xyz',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isTrue(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, 'wss://mercury.example.com:443/path');
+        assert.equal(result.deviceSocketUrl, 'wss://device.example.com:443/path');
+      });
+
+      it('returns socket URL info when URLs match', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://example.com:443/path?token=abc',
+              },
+            },
+            device: {
+              webSocketUrl: 'wss://example.com:443/path?token=xyz',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, 'wss://example.com:443/path');
+        assert.equal(result.deviceSocketUrl, 'wss://example.com:443/path');
+      });
+
+      it('returns hasMismatchedSocket as false when one URL is proxied (partial match)', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://other.example.com/somepath/mercury.example.com/v1/apps/wx2/registrations/00000000-0000-0000-0000-000000000000/messages',
+              },
+            },
+            device: {
+              webSocketUrl:
+                'wss://mercury.example.com/v1/apps/wx2/registrations/00000000-0000-0000-0000-000000000000/messages',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(
+          result.mercurySocketUrl,
+          'wss://other.example.com/somepath/mercury.example.com/v1/apps/wx2/registrations/00000000-0000-0000-0000-000000000000/messages'
+        );
+        assert.equal(
+          result.deviceSocketUrl,
+          'wss://mercury.example.com/v1/apps/wx2/registrations/00000000-0000-0000-0000-000000000000/messages'
+        );
+      });
+
+      it('returns false for hasMismatchedSocket when mercury socket URL is missing', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {},
+            },
+            device: {
+              webSocketUrl: 'wss://device.example.com:443/path',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, '');
+        assert.equal(result.deviceSocketUrl, 'wss://device.example.com:443/path');
+      });
+
+      it('returns false for hasMismatchedSocket when device socket URL is missing', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://mercury.example.com:443/path',
+              },
+            },
+            device: {},
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, 'wss://mercury.example.com:443/path');
+        assert.equal(result.deviceSocketUrl, '');
+      });
+
+      it('returns default values when webex object is missing properties', () => {
+        const testWebex = {
+          internal: {},
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, '');
+        assert.equal(result.deviceSocketUrl, '');
+      });
+
+      it('handles error gracefully and returns default values', () => {
+        const testWebex = null;
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, '');
+        assert.equal(result.deviceSocketUrl, '');
+      });
+
+      it('sanitizes URLs by removing query parameters', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://mercury.example.com/path?secret=token123&key=value',
+              },
+            },
+            device: {
+              webSocketUrl: 'wss://device.example.com/path?secret=differenttoken&key=value',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.notInclude(result.mercurySocketUrl, 'secret');
+        assert.notInclude(result.mercurySocketUrl, 'token123');
+        assert.notInclude(result.deviceSocketUrl, 'secret');
+        assert.notInclude(result.deviceSocketUrl, 'differenttoken');
+      });
+    });
   });
 });