@webex/plugin-meetings 3.8.0-web-workers-keepalive.1 → 3.8.1-next.1

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

@@ -4,7 +4,7 @@ import {cloneDeep, defaultsDeep} from 'lodash';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 
 import {self} from './selfConstant';
-import {_IDLE_, _WAIT_} from '@webex/plugin-meetings/src/constants';
+import {_IDLE_, _WAIT_, _OBSERVE_, _NONE_} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('selfUtils', () => {
@@ -269,13 +269,18 @@ describe('plugin-meetings', () => {
     });
 
     describe('getSelves', () => {
+      let parsedSelf;
+
+      beforeEach(() => {
+        parsedSelf = SelfUtils.parse(self);
+      });
       describe('canNotViewTheParticipantListChanged', () => {
         it('should return canNotViewTheParticipantListChanged = true when changed', () => {
           const clonedSelf = cloneDeep(self);
 
           clonedSelf.canNotViewTheParticipantList = true; // different
 
-          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+          const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
           assert.equal(updates.canNotViewTheParticipantListChanged, true);
         });
@@ -285,7 +290,7 @@ describe('plugin-meetings', () => {
 
           clonedSelf.canNotViewTheParticipantList = false; // same
 
-          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+          const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
           assert.equal(updates.canNotViewTheParticipantListChanged, false);
         });
@@ -295,7 +300,7 @@ describe('plugin-meetings', () => {
         it('should return localAudioUnmuteRequestedByServer = false when requestedToUnmute = false', () => {
           const clonedSelf = cloneDeep(self);
 
-          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+          const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
           assert.equal(updates.localAudioUnmuteRequestedByServer, false);
         });
@@ -307,7 +312,7 @@ describe('plugin-meetings', () => {
           clonedSelf.controls.audio.requestedToUnmute = true;
           clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z';
 
-          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+          const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
           assert.equal(updates.localAudioUnmuteRequestedByServer, true);
         });
@@ -321,7 +326,7 @@ describe('plugin-meetings', () => {
           clonedSelf.controls.audio.requestedToUnmute = true;
           clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T19:25:04.369Z';
 
-          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+          const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
           assert.equal(updates.localAudioUnmuteRequestedByServer, true);
         });
@@ -334,70 +339,139 @@ describe('plugin-meetings', () => {
           clonedSelf.controls.audio.requestedToUnmute = true;
           clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z';
 
-          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+          const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
           assert.equal(updates.localAudioUnmuteRequestedByServer, false);
         });
       });
 
-      describe('updates.isUserUnadmitted', () => {
-        const testIsUserUnadmitted = (previousObjectDelta, currentObjectDelta, expected) => function () {
-          const previous =
-            previousObjectDelta === undefined ? undefined : defaultsDeep(previousObjectDelta, self);
-          const current = defaultsDeep(currentObjectDelta, self);
-
-          const {updates} = SelfUtils.getSelves(previous, current, self.devices[0].url);
-
-          assert.equal(updates.isUserUnadmitted, expected);
-        };
+      describe('updates.hasUserEnteredLobby', () => {
+        const testIsUserUnadmitted = (
+          previousParsedSelves,
+          currentSelfDelta,
+          participants,
+          expected
+        ) =>
+          function () {
+            const currentSelf = defaultsDeep(currentSelfDelta, self);
+
+            if (previousParsedSelves === undefined) {
+              parsedSelf.state = undefined;
+            } else {
+              parsedSelf = defaultsDeep(previousParsedSelves, parsedSelf);
+            }
+            const {updates} = SelfUtils.getSelves(
+              parsedSelf,
+              currentSelf,
+              currentSelf.devices[0].url,
+              participants
+            );
+
+            assert.equal(updates.hasUserEnteredLobby, expected);
+          };
 
         it(
           'should return true when previous is undefined and current is in lobby',
           testIsUserUnadmitted(
             undefined,
             {devices: [{intent: {type: _WAIT_}}], state: _IDLE_},
+            [],
             true
           )
         );
 
         it(
           'should return false when previous is undefined and user is not in meeting',
-          testIsUserUnadmitted(undefined, {devices: [], state: _IDLE_}, false)
+          testIsUserUnadmitted(undefined, {devices: [], state: _IDLE_}, [], false)
         );
 
         it(
           'should return false when previous is undefined and current is in meeting',
-          testIsUserUnadmitted(undefined, {}, false)
+          testIsUserUnadmitted(undefined, {}, [], false)
+        );
+
+        it(
+          'should return true when previous is undefined and current is in lobby with paired device',
+          testIsUserUnadmitted(
+            undefined,
+            {
+              devices: [{intent: {type: _OBSERVE_, associatedWith: 'pairedDeviceUrl'}}],
+              state: _IDLE_,
+            },
+            [{url: 'pairedDeviceUrl', devices: [{intent: {type: _WAIT_}}]}],
+            true
+          )
+        );
+
+        it(
+          'should return false when previous is in lobby with paired device and current is the same',
+          testIsUserUnadmitted(
+            {
+              pairedWith: {intent: {type: _WAIT_}},
+              joinedWith: {intent: {type: _OBSERVE_}},
+              state: _IDLE_,
+            },
+            {
+              devices: [{intent: {type: _OBSERVE_, associatedWith: 'pairedDeviceUrl'}}],
+              state: _IDLE_,
+            },
+            [{url: 'pairedDeviceUrl', devices: [{intent: {type: _WAIT_}}]}],
+            false
+          )
         );
 
         it(
           'should return false when previous is in lobby and current is in lobby',
           testIsUserUnadmitted(
+            {joinedWith: {intent: {type: _WAIT_}}, state: _IDLE_},
             {devices: [{intent: {type: _WAIT_}}], state: _IDLE_},
-            {devices: [{intent: {type: _WAIT_}}], state: _IDLE_},
+            [],
+            false
+          )
+        );
+
+        it(
+          'should return false when previous is in lobby with paired device and current is in the meeting',
+          testIsUserUnadmitted(
+            {
+              pairedWith: {intent: {type: _WAIT_}},
+              joinedWith: {intent: {type: _OBSERVE_}},
+              state: _IDLE_,
+            },
+            {
+              devices: [{intent: {type: _OBSERVE_, associatedWith: 'pairedDeviceUrl'}}],
+              state: _IDLE_,
+            },
+            [{url: 'pairedDeviceUrl', devices: [{intent: {type: _NONE_}}]}],
             false
           )
         );
 
         it(
           'should return false when previous is in lobby and current is in meeting',
-          testIsUserUnadmitted({devices: [{intent: {type: _WAIT_}}], state: _IDLE_}, {}, false)
+          testIsUserUnadmitted({joinedWith: {intent: {type: _WAIT_}}, state: _IDLE_}, {}, [], false)
         );
 
         it(
           'should return true when previous is in meeting and current is in lobby',
-          testIsUserUnadmitted({}, {devices: [{intent: {type: _WAIT_}}], state: _IDLE_}, true)
+          testIsUserUnadmitted({}, {devices: [{intent: {type: _WAIT_}}], state: _IDLE_}, [], true)
         );
       });
     });
 
     describe('isSharingBlocked', () => {
+      let parsedSelf;
+
+      beforeEach(() => {
+        parsedSelf = SelfUtils.parse(self);
+      });
+
       it('should return isSharingBlockedChanged = true when changed', () => {
         const clonedSelf = cloneDeep(self);
 
         clonedSelf.isSharingBlocked = true; // different
 
-        const {updates} = SelfUtils.getSelves(self, clonedSelf);
+        const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
         assert.equal(updates.isSharingBlockedChanged, true);
       });
@@ -407,7 +481,7 @@ describe('plugin-meetings', () => {
 
         clonedSelf.isSharingBlocked = false; // same
 
-        const {updates} = SelfUtils.getSelves(self, clonedSelf);
+        const {updates} = SelfUtils.getSelves(parsedSelf, clonedSelf);
 
         assert.equal(updates.isSharingBlockedChanged, false);
       });

package/test/unit/spec/media/index.ts

@@ -4,6 +4,7 @@ import Media from '@webex/plugin-meetings/src/media/index';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
+import {BrowserInfo} from '@webex/web-capabilities';
 
 describe('createMediaConnection', () => {
   let clock;
@@ -79,7 +80,10 @@ describe('createMediaConnection', () => {
       enableRtx: ENABLE_RTX,
       enableExtmap: ENABLE_EXTMAP,
       turnServerInfo: {
-        url: 'turns:turn-server-url:443?transport=tcp',
+        urls: [
+          'turns:turn-server-url-1:443?transport=tcp',
+          'turns:turn-server-url-2:443?transport=tcp',
+        ],
         username: 'turn username',
         password: 'turn password',
       },
@@ -91,12 +95,10 @@ describe('createMediaConnection', () => {
       {
         iceServers: [
           {
-            urls: 'turn:turn-server-url:5004?transport=tcp',
-            username: 'turn username',
-            credential: 'turn password',
-          },
-          {
-            urls: 'turns:turn-server-url:443?transport=tcp',
+            urls: [
+              'turns:turn-server-url-1:443?transport=tcp',
+              'turns:turn-server-url-2:443?transport=tcp',
+            ],
             username: 'turn username',
             credential: 'turn password',
           },
@@ -159,11 +161,16 @@ describe('createMediaConnection', () => {
       },
       rtcMetrics,
       turnServerInfo: {
-        url: 'turns:turn-server-url:443?transport=tcp',
+        urls: [
+          'turns:turn-server-url-1:443?transport=tcp',
+          'turns:turn-server-url-2:443?transport=tcp',
+        ],
         username: 'turn username',
         password: 'turn password',
       },
       bundlePolicy: 'max-bundle',
+      disableAudioMainDtx: false,
+      enableAudioTwcc: true,
     });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
@@ -171,25 +178,27 @@ describe('createMediaConnection', () => {
       {
         iceServers: [
           {
-            urls: 'turn:turn-server-url:5004?transport=tcp',
-            username: 'turn username',
-            credential: 'turn password',
-          },
-          {
-            urls: 'turns:turn-server-url:443?transport=tcp',
+            urls: [
+              'turns:turn-server-url-1:443?transport=tcp',
+              'turns:turn-server-url-2:443?transport=tcp',
+            ],
             username: 'turn username',
             credential: 'turn password',
           },
         ],
         bundlePolicy: 'max-bundle',
+        disableAudioMainDtx: false,
+        disableAudioTwcc: false,
       },
       'meeting id'
     );
 
     // check if rtcMetrics callbacks are configured correctly
     const addMetricsCallback = multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[2];
-    const closeMetricsCallback = multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[3];
-    const sendMetricsInQueueCallback = multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[4];
+    const closeMetricsCallback =
+      multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[3];
+    const sendMetricsInQueueCallback =
+      multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[4];
 
     assert.isFunction(addMetricsCallback);
     assert.isFunction(closeMetricsCallback);
@@ -205,14 +214,78 @@ describe('createMediaConnection', () => {
 
     sendMetricsInQueueCallback();
     assert.calledOnce(rtcMetrics.sendMetricsInQueue);
+  });
+
+  it('multistream non-firefox does not care about stopIceGatheringAfterFirstRelayCandidate', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'some debug id', 'meeting id', {
+      stopIceGatheringAfterFirstRelayCandidate: true,
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        disableAudioTwcc: true,
+      },
+      'meeting id'
+    );
+  });
+
+  it('multistream firefox stops gathering after first relay if stopIceGatheringAfterFirstRelayCandidate is true', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    sinon.stub(BrowserInfo, 'isFirefox').returns(true);
 
+    Media.createMediaConnection(true, 'some debug id', 'meeting id', {
+      stopIceGatheringAfterFirstRelayCandidate: true,
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        doFullIce: true,
+        stopIceGatheringAfterFirstRelayCandidate: true,
+        disableAudioTwcc: true,
+      },
+      'meeting id'
+    );
+  });
+
+  it('multistream firefox continues gathering if stopIceGatheringAfterFirstRelayCandidate is false', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    sinon.stub(BrowserInfo, 'isFirefox').returns(true);
+
+    Media.createMediaConnection(true, 'some debug id', 'meeting id', {
+      stopIceGatheringAfterFirstRelayCandidate: false,
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        doFullIce: true,
+        stopIceGatheringAfterFirstRelayCandidate: false,
+        disableAudioTwcc: true,
+      },
+      'meeting id'
+    );
   });
 
   [
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
     {
       testCase: 'turnServerInfo.url is empty string',
-      turnServerInfo: {url: '', username: 'turn username', password: 'turn password'},
+      turnServerInfo: {urls: [], username: 'turn username', password: 'turn password'},
     },
   ].forEach(({testCase, turnServerInfo}) => {
     it(`passes empty ICE servers array to MultistreamRoapMediaConnection if ${testCase} (multistream enabled)`, () => {
@@ -238,6 +311,7 @@ describe('createMediaConnection', () => {
         multistreamRoapMediaConnectionConstructorStub,
         {
           iceServers: [],
+          disableAudioTwcc: true,
         },
         'meeting id'
       );
@@ -267,6 +341,64 @@ describe('createMediaConnection', () => {
       multistreamRoapMediaConnectionConstructorStub,
       {
         iceServers: [],
+        disableAudioTwcc: true,
+      },
+      'meeting id'
+    );
+  });
+
+  it('does not pass disableAudioMainDtx to MultistreamRoapMediaConnection if disableAudioMainDtx is undefined', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+      disableAudioMainDtx: undefined,
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        disableAudioTwcc: true,
+      },
+      'meeting id'
+    );
+  });
+
+  it('MultistreamRoapMediaConnection disable audio twcc by default', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+    });
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        disableAudioTwcc: true,
       },
       'meeting id'
     );
@@ -276,7 +408,7 @@ describe('createMediaConnection', () => {
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
     {
       testCase: 'turnServerInfo.url is empty string',
-      turnServerInfo: {url: '', username: 'turn username', password: 'turn password'},
+      turnServerInfo: {urls: [], username: 'turn username', password: 'turn password'},
     },
   ].forEach(({testCase, turnServerInfo}) => {
     it(`passes empty ICE servers array to RoapMediaConnection if ${testCase} (multistream disabled)`, () => {

package/test/unit/spec/media/properties.ts

@@ -2,6 +2,7 @@ import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import {ConnectionState} from '@webex/internal-media-core';
+import * as tsSdpModule from '@webex/ts-sdp';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import {Defer} from '@webex/common';
 import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
@@ -10,15 +11,21 @@ describe('MediaProperties', () => {
   let mediaProperties;
   let mockMC;
   let clock;
+  let rtcPeerConnection;
 
   beforeEach(() => {
     clock = sinon.useFakeTimers();
 
+    rtcPeerConnection = {
+      localDescription: {sdp: ''},
+    };
+
     mockMC = {
       getStats: sinon.stub().resolves([]),
       on: sinon.stub(),
       off: sinon.stub(),
       getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+      multistreamConnection: {pc: {pc: rtcPeerConnection}},
     };
 
     mediaProperties = new MediaProperties();
@@ -81,6 +88,129 @@ describe('MediaProperties', () => {
       assert.equal(numTransports, 0);
     });
 
+    describe('ipVersion', () => {
+      it('returns ipVersion=undefined if getStats() returns no candidate pairs', async () => {
+        mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
+        const info = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(info.ipVersion, undefined);
+      });
+
+      it('returns ipVersion=undefined if getStats() returns no selected candidate pair', async () => {
+        mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', selected: false}]);
+        const info = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(info.ipVersion, undefined);
+      });
+
+      it('returns ipVersion="IPv4" if transport has selectedCandidatePairId and local candidate has IPv4 address', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: 't1', selectedCandidatePairId: 'cp1'},
+          {type: 'candidate-pair', id: 'cp1', localCandidateId: 'lc1'},
+          {type: 'local-candidate', id: 'lc1', address: '192.168.1.1'},
+        ]);
+        const info = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(info.ipVersion, 'IPv4');
+      });
+
+      it('returns ipVersion="IPv6" if transport has selectedCandidatePairId and local candidate has IPv6 address', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: 't1', selectedCandidatePairId: 'cp1'},
+          {type: 'candidate-pair', id: 'cp1', localCandidateId: 'lc1'},
+          {type: 'local-candidate', id: 'lc1', address: 'fd8f:12e6:5e53:784f:a0ba:f8d5:b906:1acc'},
+        ]);
+        const info = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(info.ipVersion, 'IPv6');
+      });
+
+      it('returns ipVersion="IPv4" if transport has no selectedCandidatePairId but finds selected candidate pair and local candidate has IPv4 address', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: 't1'},
+          {type: 'candidate-pair', id: 'cp2', localCandidateId: 'lc2', selected: true},
+          {type: 'local-candidate', id: 'lc2', address: '10.0.0.1'},
+        ]);
+        const info = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(info.ipVersion, 'IPv4');
+      });
+
+      it('returns ipVersion="IPv6" if transport has no selectedCandidatePairId but finds selected candidate pair and local candidate has IPv6 address', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: 't1'},
+          {type: 'candidate-pair', id: 'cp2', localCandidateId: 'lc2', selected: true},
+          {type: 'local-candidate', id: 'lc2', address: 'fe80::1ff:fe23:4567:890a'},
+        ]);
+        const info = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(info.ipVersion, 'IPv6');
+      });
+
+      describe('local candidate without address', () => {
+        it('return="IPv4" if candidate from SDP with matching port number has IPv4 address', async () => {
+          sinon.stub(tsSdpModule, 'parse').returns({
+            avMedia: [
+              {
+                iceInfo: {
+                  candidates: [
+                    {
+                      port: 1234,
+                      connectionAddress: '192.168.0.1',
+                    },
+                  ],
+                },
+              },
+            ],
+          });
+
+          mockMC.getStats.resolves([
+            {type: 'transport', id: 't1'},
+            {type: 'candidate-pair', id: 'cp2', localCandidateId: 'lc2', selected: true},
+            {type: 'local-candidate', id: 'lc2', port: 1234},
+          ]);
+          const info = await mediaProperties.getCurrentConnectionInfo();
+          assert.equal(info.ipVersion, 'IPv4');
+
+          assert.calledWith(tsSdpModule.parse, rtcPeerConnection.localDescription.sdp);
+        });
+
+        it('returns ipVersion="IPv6" if candidate from SDP with matching port number has IPv6 address', async () => {
+          sinon.stub(tsSdpModule, 'parse').returns({
+            avMedia: [
+              {
+                iceInfo: {
+                  candidates: [
+                    {
+                      port: 5000,
+                      connectionAddress: 'fe80::1ff:fe23:4567:890a',
+                    },
+                  ],
+                },
+              },
+            ],
+          });
+
+          mockMC.getStats.resolves([
+            {type: 'transport', id: 't1'},
+            {type: 'candidate-pair', id: 'cp2', localCandidateId: 'lc2', selected: true},
+            {type: 'local-candidate', id: 'lc2', port: 5000},
+          ]);
+          const info = await mediaProperties.getCurrentConnectionInfo();
+          assert.equal(info.ipVersion, 'IPv6');
+
+          assert.calledWith(tsSdpModule.parse, rtcPeerConnection.localDescription.sdp);
+        });
+
+        it('returns ipVersion=undefined if parsing of the SDP fails', async () => {
+          sinon.stub(tsSdpModule, 'parse').throws(new Error('fake error'));
+
+          mockMC.getStats.resolves([
+            {type: 'candidate-pair', id: 'cp2', localCandidateId: 'lc2', selected: true},
+            {type: 'local-candidate', id: 'lc2', port: 5000},
+          ]);
+          const info = await mediaProperties.getCurrentConnectionInfo();
+          assert.equal(info.ipVersion, undefined);
+
+          assert.calledWith(tsSdpModule.parse, rtcPeerConnection.localDescription.sdp);
+        });
+      });
+    });
+
     describe('selectedCandidatePairChanges and numTransports', () => {
       it('returns correct values when getStats() returns no transport stats at all', async () => {
         mockMC.getStats.resolves([{type: 'something', id: '1234'}]);