@webex/plugin-meetings 3.0.0-stream-classes.3 → 3.0.0-stream-classes.5

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

@@ -10,6 +10,7 @@ import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 import EmbeddedAppsUtils from '@webex/plugin-meetings/src/locus-info/embeddedAppsUtils';
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import {
   LOCUSINFO,
@@ -24,7 +25,6 @@ import {
 } from '../../../../src/constants';
 
 import {self, selfWithInactivity} from './selfConstant';
-import uuid from 'uuid';
 
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
@@ -39,6 +39,7 @@ describe('plugin-meetings', () => {
     const locus = {};
     const meetingId = 'meetingId';
     let locusInfo;
+    let sendBehavioralMetricStub;
 
     const webex = new MockWebex({
       children: {
@@ -65,6 +66,12 @@ describe('plugin-meetings', () => {
           },
         },
       };
+
+      sendBehavioralMetricStub = sinon.stub(Metrics, 'sendBehavioralMetric');
+    });
+
+    afterEach(() => {
+      sinon.restore();
     });
 
     describe('#updateControls', () => {
@@ -1877,6 +1884,114 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('edge cases for sync failing', () => {
+        const {DESYNC} = LocusDeltaParser.loci;
+        const fakeFullLocusDto = {id: 'fake full locus dto'};
+        let meeting;
+
+        beforeEach(() => {
+          sinon.stub(locusInfo.locusParser, 'resume');
+          sinon.stub(webex.meetings, 'destroy');
+
+          meeting = {
+            meetingRequest: {
+              getLocusDTO: sandbox.stub(),
+            },
+            locusInfo: {
+              handleLocusDelta: sandbox.stub(),
+              onFullLocus: sandbox.stub(),
+            },
+            locusUrl: 'fullSyncUrl',
+          };
+
+          locusInfo.locusParser.workingCopy = {
+            syncUrl: 'deltaSyncUrl',
+          };
+        });
+
+        it('applyLocusDeltaData gets full locus on DESYNC action if we do not have a syncUrl and destroys the meeting if that fails', () => {
+          meeting.meetingRequest.getLocusDTO.rejects(new Error('fake error'));
+
+          locusInfo.locusParser.workingCopy = {}; // no syncUrl
+
+          // Since we have a promise inside a function we want to test that's not returned,
+          // we will wait and stub it's last function to resolve this waiting promise.
+          return new Promise((resolve) => {
+            webex.meetings.destroy.callsFake(() => resolve());
+            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+          }).then(() => {
+            assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'fullSyncUrl'});
+
+            assert.notCalled(meeting.locusInfo.handleLocusDelta);
+            assert.notCalled(meeting.locusInfo.onFullLocus);
+            assert.notCalled(locusInfo.locusParser.resume);
+
+            assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
+          });
+        });
+
+        it('applyLocusDeltaData first tries a delta sync on DESYNC action and if that fails, does a full locus sync', () => {
+          meeting.meetingRequest.getLocusDTO.onCall(0).rejects(new Error('fake error'));
+          meeting.meetingRequest.getLocusDTO.onCall(1).resolves({body: fakeFullLocusDto});
+
+          // Since we have a promise inside a function we want to test that's not returned,
+          // we will wait and stub it's last function to resolve this waiting promise.
+          return new Promise((resolve) => {
+            locusInfo.locusParser.resume.callsFake(() => resolve());
+            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+          }).then(() => {
+            assert.calledTwice(meeting.meetingRequest.getLocusDTO);
+
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [{url: 'deltaSyncUrl'}]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [{url: 'fullSyncUrl'}]);
+
+            assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
+              correlationId: meeting.correlationId,
+              url: 'deltaSyncUrl',
+              reason: 'fake error',
+              errorName: 'Error',
+              stack: sinon.match.any,
+              code: sinon.match.any,
+            });
+
+            assert.notCalled(meeting.locusInfo.handleLocusDelta);
+            assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
+            assert.calledOnce(locusInfo.locusParser.resume);
+          });
+        });
+
+        it('applyLocusDeltaData destroys the meeting if both delta sync and full sync fail', () => {
+          meeting.meetingRequest.getLocusDTO.rejects(new Error('fake error'));
+
+          // Since we have a promise inside a function we want to test that's not returned,
+          // we will wait and stub it's last function to resolve this waiting promise.
+          return new Promise((resolve) => {
+            webex.meetings.destroy.callsFake(() => resolve());
+            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+          }).then(() => {
+            assert.calledTwice(meeting.meetingRequest.getLocusDTO);
+
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [{url: 'deltaSyncUrl'}]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [{url: 'fullSyncUrl'}]);
+
+            assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
+              correlationId: meeting.correlationId,
+              url: 'deltaSyncUrl',
+              reason: 'fake error',
+              errorName: 'Error',
+              stack: sinon.match.any,
+              code: sinon.match.any,
+            });
+
+            assert.notCalled(meeting.locusInfo.handleLocusDelta);
+            assert.notCalled(meeting.locusInfo.onFullLocus);
+            assert.notCalled(locusInfo.locusParser.resume);
+
+            assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
+          });
+        });
+      });
+
       it('onDeltaLocus handle delta data', () => {
         fakeLocus.participants = {};
         const fakeBreakout = {
@@ -2420,6 +2535,8 @@ describe('plugin-meetings', () => {
         // send an out-of-order delta
         locusInfo.handleLocusDelta(oooDelta, mockMeeting);
 
+        assert.calledOnceWithExactly(sendBehavioralMetricStub, 'js_sdk_locus_delta_ooo', { stack: sinon.match.any})
+
         await clock.tickAsync(12499);
         await testUtils.flushPromises();
         assert.notCalled(syncRequestStub);

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

@@ -1406,9 +1406,10 @@ describe('plugin-meetings', () => {
         });
 
         it('should reject if waitForMediaConnectionConnected() rejects', async () => {
-          webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode = sinon
+          const FAKE_ERROR = {fatal: true};
+          const getErrorPayloadForClientErrorCodeStub = webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode = sinon
             .stub()
-            .returns({});
+            .returns(FAKE_ERROR);
           meeting.meetingState = 'ACTIVE';
           meeting.mediaProperties.waitForMediaConnectionConnected.rejects(new Error('fake error'));
 
@@ -1422,14 +1423,14 @@ describe('plugin-meetings', () => {
               errorThrown = true;
             });
 
+          assert.calledOnceWithExactly(getErrorPayloadForClientErrorCodeStub, {clientErrorCode: 2004});
           assert.calledTwice(webex.internal.newMetrics.submitClientEvent);
-
           assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.ice.end',
             payload: {
               canProceed: false,
               icePhase: 'JOIN_MEETING_FINAL',
-              errors: [{}],
+              errors: [FAKE_ERROR],
             },
             options: {
               meetingId: meeting.id,
@@ -1674,6 +1675,8 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           clock = sinon.useFakeTimers();
 
+          sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+
           meeting.deviceUrl = 'deviceUrl';
           meeting.config.deviceType = 'web';
           meeting.isMultistream = isMultistream;
@@ -1687,12 +1690,11 @@ describe('plugin-meetings', () => {
           meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
           meeting.webex.meetings.reachability = {
             isAnyClusterReachable: sinon.stub().resolves(true),
-            getIpVersion: () => IP_VERSION.unknown,
           };
           meeting.roap.doTurnDiscovery = sinon
             .stub()
             .resolves({turnServerInfo: {}, turnDiscoverySkippedReason: 'reachability'});
-          
+
           StaticConfig.set({bandwidth: {audio: 1234, video: 5678, startBitrate: 9876}});
 
           // setup things that are expected to be the same across all the tests and are actually irrelevant for these tests
@@ -1768,6 +1770,7 @@ describe('plugin-meetings', () => {
 
         afterEach(() => {
           clock.restore();
+          sinon.restore();
         });
 
         // helper function that waits until all promises are resolved and any queued up /media requests to Locus are sent out
@@ -1855,7 +1858,7 @@ describe('plugin-meetings', () => {
               ],
               clientMediaPreferences: {
                 preferTranscoding: !meeting.isMultistream,
-                ipver: 0
+                ipver: undefined
               },
               respOnlySdp: true,
               usingResource: null,
@@ -1936,7 +1939,7 @@ describe('plugin-meetings', () => {
           // and that it was the only /media request that was sent
           assert.calledOnce(locusMediaRequestStub);
         });
-          
+
         it('addMedia() works correctly when media is enabled with streams to publish', async () => {
           await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
           await simulateRoapOffer();
@@ -2083,7 +2086,7 @@ describe('plugin-meetings', () => {
                 } else {
                   assert.notCalled(locusMediaRequestStub);
                 }
-                
+
                 if (isMultistream) {
                   assert.calledOnceWithExactly(meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream, fakeMicrophoneStream);
                 } else {
@@ -4485,20 +4488,22 @@ describe('plugin-meetings', () => {
 
         describe('submitClientEvent on connectionFailed', () => {
           it('sends client.ice.end when connectionFailed on CONNECTION_STATE_CHANGED event', () => {
-            webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode =
-              sinon.stub().returns({});
+            const FAKE_ERROR = {fatal: true};
+            const getErrorPayloadForClientErrorCodeStub = webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode = sinon
+              .stub()
+              .returns(FAKE_ERROR);
             meeting.setupMediaConnectionListeners();
             eventListeners[Event.CONNECTION_STATE_CHANGED]({
               state: 'Failed',
             });
+            assert.calledOnceWithExactly(getErrorPayloadForClientErrorCodeStub, {clientErrorCode: 2004});
             assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
-
             assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
               name: 'client.ice.end',
               payload: {
                 canProceed: false,
                 icePhase: 'IN_MEETING',
-                errors: [{}],
+                errors: [FAKE_ERROR],
               },
               options: {
                 meetingId: meeting.id,
@@ -5557,29 +5562,40 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#setPermissionTokenPayload', () => {
+        it('sets correctly', () => {
+          assert.notOk(meeting.permissionTokenPayload);
+
+          const permissionTokenPayloadData = {permission: {userPolicies: {a: true}}, exp: '1234'};
+          
+          const jwtDecodeStub = sinon.stub(jwt, 'decode').returns(permissionTokenPayloadData);
+          
+          meeting.setPermissionTokenPayload();
+
+          assert.calledOnce(jwtDecodeStub);
+          assert.deepEqual(meeting.permissionTokenPayload, permissionTokenPayloadData);
+        });
+      });
+
       describe('#setSelfUserPolicies', () => {
         it('sets correctly when policy data is present in token', () => {
           assert.notOk(meeting.selfUserPolicies);
 
-          const dummyToken = 'some data';
           const policyData = {permission: {userPolicies: {a: true}}};
+          meeting.permissionTokenPayload = policyData;
 
-          sinon.stub(jwt, 'decode').returns(policyData);
-
-          meeting.setSelfUserPolicies(dummyToken);
+          meeting.setSelfUserPolicies();
 
-          assert.deepEqual(meeting.selfUserPolicies, {a: true});
+          assert.deepEqual(meeting.selfUserPolicies, policyData.permission.userPolicies);
         });
 
         it('handles missing permission data', () => {
           assert.notOk(meeting.selfUserPolicies);
 
-          const dummyToken = 'some data';
           const policyData = {};
+          meeting.permissionTokenPayload = policyData;
 
-          sinon.stub(jwt, 'decode').returns(policyData);
-
-          meeting.setSelfUserPolicies(dummyToken);
+          meeting.setSelfUserPolicies();
 
           assert.deepEqual(meeting.selfUserPolicies, undefined);
         });
@@ -5587,12 +5603,10 @@ describe('plugin-meetings', () => {
         it('handles missing policy data', () => {
           assert.notOk(meeting.selfUserPolicies);
 
-          const dummyToken = 'some data';
           const policyData = {permission: {}};
+          meeting.permissionTokenPayload = policyData;
 
-          sinon.stub(jwt, 'decode').returns(policyData);
-
-          meeting.setSelfUserPolicies(dummyToken);
+          meeting.setSelfUserPolicies();
 
           assert.deepEqual(meeting.selfUserPolicies, undefined);
         });
@@ -5652,19 +5666,37 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.owner, expectedInfoToParse.owner);
           assert.equal(meeting.permissionToken, expectedInfoToParse.permissionToken);
           assert.deepEqual(meeting.selfUserPolicies, expectedInfoToParse.selfUserPolicies);
+          
+          if(expectedInfoToParse.permissionTokenPayload) {
+            assert.deepEqual(meeting.permissionTokenPayload, expectedInfoToParse.permissionTokenPayload);
+          }
         };
 
         it('should parse meeting info from api return when locus meeting object is not available, set values, and return null', () => {
           meeting.config.experimental = {enableMediaNegotiatedEvent: true};
           meeting.config.experimental.enableUnifiedMeetings = true;
+
+          const expectedPermissionTokenPayload = {
+            exp: "123456",
+            permission: {
+              userPolicies: {
+                a: true
+              }
+            }
+          };
+
+          // generated permissionToken with secret `secret` and 
+          // value `JSON.stringify(expectedPermissionTokenPayload)`
+          const permissionToken = 
+            'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0';
+
           const FAKE_MEETING_INFO = {
             body: {
               conversationUrl: uuid1,
               locusUrl: url1,
               meetingJoinUrl: url2,
               meetingNumber: '12345',
-              permissionToken:
-                'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX0sImlhdCI6MTY4OTE2NDEwMn0.9uL_U7QUdYyMerrgHC_gCKOax2j_bz04u8Ikbv9KiXU',
+              permissionToken,
               sipMeetingUri: test1,
               sipUrl: test1,
               owner: test2,
@@ -5672,6 +5704,7 @@ describe('plugin-meetings', () => {
           };
 
           meeting.parseMeetingInfo(FAKE_MEETING_INFO);
+
           const expectedInfoToParse = {
             conversationUrl: uuid1,
             locusUrl: url1,
@@ -5680,8 +5713,8 @@ describe('plugin-meetings', () => {
             meetingJoinUrl: url2,
             owner: test2,
             selfUserPolicies: {a: true},
-            permissionToken:
-              'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX0sImlhdCI6MTY4OTE2NDEwMn0.9uL_U7QUdYyMerrgHC_gCKOax2j_bz04u8Ikbv9KiXU',
+            permissionToken,
+            permissionTokenPayload: expectedPermissionTokenPayload
           };
 
           checkParseMeetingInfo(expectedInfoToParse);
@@ -7991,4 +8024,36 @@ describe('plugin-meetings', () => {
       });
     });
   });
+
+  describe('#getPermissionTokenTimeLeftInSec', () => {
+    let now;
+    let clock;
+
+    beforeEach(() => {
+      now = Date.now();
+
+      // mock `new Date()` with constant `now`
+      clock = sinon.useFakeTimers(now);
+    });
+
+    afterEach(() => {
+      clock.restore();  
+    })
+
+    it('should return undefined if exp is undefined', () => { 
+      assert.equal(meeting.getPermissionTokenTimeLeftInSec(), undefined)
+    });
+
+    it('should return the expected positive exp', () => { 
+      // set permission token as now + 1 sec
+      meeting.permissionTokenPayload = {exp: (now + 1000).toString()};
+      assert.equal(meeting.getPermissionTokenTimeLeftInSec(), 1);
+    });
+
+    it('should return the expected negative exp', () => { 
+      // set permission token as now - 1 sec
+      meeting.permissionTokenPayload = {exp: (now - 1000).toString()};
+      assert.equal(meeting.getPermissionTokenTimeLeftInSec(), -1);
+    });
+  });
 });

package/test/unit/spec/meeting/locusMediaRequest.ts

@@ -68,7 +68,6 @@ describe('LocusMediaRequest.send()', () => {
     mediaId: 'mediaId',
     selfUrl: 'fakeMeetingSelfUrl',
     muteOptions: {},
-    ipVersion: IP_VERSION.only_ipv6
   };
 
   const createExpectedLocalMuteBody = (expectedMute:{audioMuted: boolean, videoMuted: boolean}, sequence = undefined) => {
@@ -89,7 +88,7 @@ describe('LocusMediaRequest.send()', () => {
       ],
       clientMediaPreferences: {
         preferTranscoding: true,
-        ipver: 6,
+        ipver: undefined,
       },
     };
 

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

@@ -237,6 +237,29 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.invitee.address, 'sipUrl');
       });
 
+      it('sends uses the locusClusterUrl if available', async () => {
+        const deviceUrl = 'deviceUrl';
+        const correlationId = 'random-uuid';
+        const roapMessage = 'roap-message';
+        const inviteeAddress = 'sipUrl';
+        const locusClusterUrl = 'locusClusterUrl';
+
+        await meetingsRequest.joinMeeting({
+          deviceUrl,
+          correlationId,
+          roapMessage,
+          locusClusterUrl,
+          inviteeAddress,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(
+          requestParams.uri,
+          'https://locusClusterUrl/locus/api/v1/loci/call?alternateRedirect=true'
+        );
+      });
+
       it('adds deviceCapabilities to request when breakouts are supported', async () => {
         await meetingsRequest.joinMeeting({
           breakoutsSupported: true,

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

@@ -4,10 +4,9 @@ import Meetings from '@webex/plugin-meetings';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
-import Metrics from '@webex/plugin-meetings/src/metrics/index';
-import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
-import {DISPLAY_HINTS} from '@webex/plugin-meetings/src/constants';
+import {SELF_POLICY, IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import MockWebex from '@webex/test-helper-mock-webex';
+import * as BrowserDetectionModule from '@webex/plugin-meetings/src/common/browser-detection';
 
 describe('plugin-meetings', () => {
   let webex;
@@ -337,7 +336,6 @@ describe('plugin-meetings', () => {
           selfUrl: 'self url',
           sequence: {},
           type: 'LocalMute',
-          ipVersion: 0,
         });
 
         assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
@@ -517,6 +515,26 @@ describe('plugin-meetings', () => {
         assert.isUndefined(parameter.inviteeAddress);
         assert.equal(parameter.meetingNumber, 'meetingNumber');
       });
+
+      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),
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {});
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.locusClusterUrl, 'locusClusterUrl');
+      });
     });
 
     describe('joinMeetingOptions', () => {
@@ -963,5 +981,56 @@ describe('plugin-meetings', () => {
         assert.equal(result, input);
       });
     });
+
+    describe('getIpVersion', () => {
+      let isBrowserStub;
+      beforeEach(() => {
+        isBrowserStub = sinon.stub().returns(false);
+
+        sinon.stub(BrowserDetectionModule, 'default').returns({
+          isBrowser: isBrowserStub,
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      [
+        {supportsIpV4: undefined, supportsIpV6: undefined, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: undefined, supportsIpV6: true, expectedOutput: IP_VERSION.only_ipv6},
+        {supportsIpV4: undefined, supportsIpV6: false, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: true, supportsIpV6: undefined, expectedOutput: IP_VERSION.only_ipv4},
+        {supportsIpV4: true, supportsIpV6: true, expectedOutput: IP_VERSION.ipv4_and_ipv6},
+        {supportsIpV4: true, supportsIpV6: false, expectedOutput: IP_VERSION.only_ipv4},
+        {supportsIpV4: false, supportsIpV6: undefined, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: false, supportsIpV6: true, expectedOutput: IP_VERSION.only_ipv6},
+        {supportsIpV4: false, supportsIpV6: false, expectedOutput: IP_VERSION.unknown},
+      ].forEach(({supportsIpV4, supportsIpV6, expectedOutput}) => {
+        it(`returns ${expectedOutput} when supportsIpV4=${supportsIpV4} and supportsIpV6=${supportsIpV6}`, () => {
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+            .get(() => supportsIpV4);
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+            .get(() => supportsIpV6);
+
+          assert.equal(MeetingUtil.getIpVersion(webex), expectedOutput);
+        });
+
+        it(`returns undefined when supportsIpV4=${supportsIpV4} and supportsIpV6=${supportsIpV6} and browser is firefox`, () => {
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+            .get(() => supportsIpV4);
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+            .get(() => supportsIpV6);
+
+          isBrowserStub.callsFake((name) => name === 'firefox');
+
+          assert.equal(MeetingUtil.getIpVersion(webex), undefined);
+        });
+      });
+    });
   });
 });