@webex/plugin-meetings 3.8.0-next.7 → 3.8.0-next.70

package/src/roap/types.ts

@@ -0,0 +1,23 @@
+import {Enum} from '../constants';
+
+export const TurnDiscoverySkipReason = {
+  missingHttpResponse: 'missing http response', // when we asked for the TURN discovery response to be in the http response, but it wasn't there
+  reachability: 'reachability', // when udp reachability to public clusters is ok, so we don't need TURN (this doens't apply when joinWithMedia() is used)
+  alreadyInProgress: 'already in progress', // when we try to start TURN discovery while it's already in progress
+} as const;
+
+export type TurnDiscoverySkipReason =
+  | Enum<typeof TurnDiscoverySkipReason> // this is a kind of FYI, because in practice typescript will infer the type of TurnDiscoverySkipReason as a string
+  | string // used in case of errors, contains the error message
+  | undefined; // used when TURN discovery is not skipped
+
+export type TurnServerInfo = {
+  urls: string[];
+  username: string;
+  password: string;
+};
+
+export type TurnDiscoveryResult = {
+  turnServerInfo?: TurnServerInfo;
+  turnDiscoverySkippedReason: TurnDiscoverySkipReason;
+};

package/test/unit/spec/controls-options-manager/util.js

@@ -406,6 +406,74 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('canUpdateAnnotation()', () => {
+        beforeEach(() => {
+          sinon.stub(ControlsOptionsUtil, 'hasHints').returns(true);
+        });
+
+        it('should call hasHints() with proper hints when `enabled` is true', () => {
+          ControlsOptionsUtil.canUpdateAnnotation({properties: {enabled: true}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_ANNOTATION_MEETING_OPTION],
+            displayHints: [],
+          });
+        });
+
+        it('should call hasHints() with proper hints when `enabled` is false', () => {
+          ControlsOptionsUtil.canUpdateAnnotation({properties: {enabled: false}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_ANNOTATION_MEETING_OPTION],
+            displayHints: [],
+          });
+        });
+
+        it('should return the resolution of hasHints()', () => {
+          const expected = 'example-return-value';
+          ControlsOptionsUtil.hasHints.returns(expected);
+
+          const results = ControlsOptionsUtil.canUpdateAnnotation({properties: {}}, []);
+
+          assert.calledOnce(ControlsOptionsUtil.hasHints);
+          assert.equal(results, expected);
+        });
+      });
+
+      describe('canUpdateRemoteDesktopControl()', () => {
+        beforeEach(() => {
+          sinon.stub(ControlsOptionsUtil, 'hasHints').returns(true);
+        });
+
+        it('should call hasHints() with proper hints when `enabled` is true', () => {
+          ControlsOptionsUtil.canUpdateRemoteDesktopControl({properties: {enabled: true}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_RDC_MEETING_OPTION],
+            displayHints: [],
+          });
+        });
+
+        it('should call hasHints() with proper hints when `enabled` is false', () => {
+          ControlsOptionsUtil.canUpdateRemoteDesktopControl({properties: {enabled: false}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_RDC_MEETING_OPTION],
+            displayHints: [],
+          });
+        });
+
+        it('should return the resolution of hasHints()', () => {
+          const expected = 'example-return-value';
+          ControlsOptionsUtil.hasHints.returns(expected);
+
+          const results = ControlsOptionsUtil.canUpdateRemoteDesktopControl({properties: {}}, []);
+
+          assert.calledOnce(ControlsOptionsUtil.hasHints);
+          assert.equal(results, expected);
+        });
+      });
+
       describe('canUpdate()', () => {
         const displayHints = [];
 
@@ -416,6 +484,8 @@ describe('plugin-meetings', () => {
           ControlsOptionsUtil.canUpdateShareControl = sinon.stub().returns(true);
           ControlsOptionsUtil.canUpdateVideo = sinon.stub().returns(true);
           ControlsOptionsUtil.canUpdateViewTheParticipantsList = sinon.stub().returns(true);
+          ControlsOptionsUtil.canUpdateAnnotation = sinon.stub().returns(true);
+          ControlsOptionsUtil.canUpdateRemoteDesktopControl = sinon.stub().returns(true);
         });
 
         it('should only call canUpdateAudio() if the scope is audio', () => {
@@ -429,6 +499,8 @@ describe('plugin-meetings', () => {
           assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
           assert.isTrue(results);
         });
 
@@ -443,6 +515,8 @@ describe('plugin-meetings', () => {
           assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
           assert.isTrue(results);
         });
 
@@ -457,6 +531,8 @@ describe('plugin-meetings', () => {
           assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
           assert.isTrue(results);
         });
 
@@ -471,6 +547,8 @@ describe('plugin-meetings', () => {
           assert.calledWith(ControlsOptionsUtil.canUpdateShareControl, displayHints);
           assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
           assert.isTrue(results);
         });
 
@@ -485,6 +563,8 @@ describe('plugin-meetings', () => {
           assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
           assert.calledWith(ControlsOptionsUtil.canUpdateVideo, control, displayHints);
           assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
           assert.isTrue(results);
         });
 
@@ -503,6 +583,44 @@ describe('plugin-meetings', () => {
             control,
             displayHints
           );
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
+          assert.isTrue(results);
+        });
+
+        it('should only call canUpdateAnnotation() if the scope is annotation', () => {
+          const control = {scope: 'annotation'};
+
+          const results = ControlsOptionsUtil.canUpdate(control, displayHints);
+
+          assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.calledWith(ControlsOptionsUtil.canUpdateAnnotation, control, displayHints);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
+          assert.isTrue(results);
+        });
+
+        it('should only call canUpdateRemoteDesktopControl() if the scope is rdc', () => {
+          const control = {scope: 'rdc'};
+
+          const results = ControlsOptionsUtil.canUpdate(control, displayHints);
+
+          assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.calledWith(
+            ControlsOptionsUtil.canUpdateRemoteDesktopControl,
+            control,
+            displayHints
+          );
           assert.isTrue(results);
         });
 
@@ -517,6 +635,8 @@ describe('plugin-meetings', () => {
           assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
           assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateAnnotation, 0);
+          assert.callCount(ControlsOptionsUtil.canUpdateRemoteDesktopControl, 0);
           assert.isFalse(results);
         });
       });

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

@@ -1,6 +1,10 @@
 import {assert} from '@webex/test-helper-chai';
 import ControlsUtils from '@webex/plugin-meetings/src/locus-info/controlsUtils';
 import controlsUtils from "@webex/plugin-meetings/src/locus-info/controlsUtils";
+import {
+  MEETING_STATE,
+  BREAKOUTS,
+} from '../../../../src/constants';
 
 const defaultControls = {
   entryExitTone: {
@@ -140,7 +144,25 @@ describe('plugin-meetings', () => {
         assert.equal(parsedControls.videoLayout.overrideDefault, newControls.videoLayout.overrideDefault);
         assert.equal(parsedControls.videoLayout.lockAttendeeViewOnStageOnly, newControls.videoLayout.lockAttendeeViewOnStageOnly);
         assert.equal(parsedControls.videoLayout.stageParameters, newControls.videoLayout.stageParameters);
+      });
+
+      it('should parse the annotationControl control', () => {
+        const newControls = {annotationControl: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
 
+        assert.equal(
+          parsedControls.annotationControl.enabled,
+          newControls.annotationControl.enabled
+        );
+      });
+
+      it('should parse the rdcControl control', () => {
+        const newControls = {rdcControl: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.rdcControl.enabled, newControls.rdcControl.enabled);
       });
 
       describe('videoEnabled', () => {
@@ -269,6 +291,14 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasPracticeSessionEnabledChanged, true);
       });
 
+      it('returns hasPracticeSessionEnabledChanged = false when enabled is false and previous state is false', () => {
+        const newControls = {practiceSession: {enabled: false}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasPracticeSessionEnabledChanged, false);
+      });
+
       it('returns hasEntryExitToneChanged = true when mode changed', () => {
         const newControls = {
           entryExitTone: {
@@ -365,6 +395,22 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasManualCaptionChanged, false);
       });
 
+      it('returns hasAnnotationControlChanged = true when changed', () => {
+        const newControls = {annotationControl: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasAnnotationControlChanged, true);
+      });
+
+      it('returns hasRemoteDesktopControlChanged = true when changed', () => {
+        const newControls = {rdcControl: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasRemoteDesktopControlChanged, true);
+      });
+
       describe('videoEnabled', () => {
         const testVideoEnabled = (oldControls, newControls, updatedProperty) => {
           const result = ControlsUtils.getControls(oldControls, newControls);
@@ -424,28 +470,76 @@ describe('plugin-meetings', () => {
 
     describe('getSessionSwitchStatus', () => {
       it('if no breakout control, return switch status both false', () => {
-        const oldControls = {};
-        const newControls = {};
-        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+        const oldLocus = {};
+        const newLocus = {};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
           isReturnToMain: false, isJoinToBreakout: false
         });
       });
 
       it('if switch session from breakout to main, return isReturnToMain as true', () => {
-        const oldControls = {breakout: {sessionType: 'BREAKOUT'}};
-        const newControls = {breakout: {sessionType: 'MAIN'}};
-        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+        const oldLocus = {controls: {breakout: {sessionType: 'BREAKOUT'}}};
+        const newLocus = {controls: {breakout: {sessionType: 'MAIN'}}};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
           isReturnToMain: true, isJoinToBreakout: false
         });
       });
 
       it('if switch session from main to breakout, return isJoinToBreakout as true', () => {
-        const oldControls = {breakout: {sessionType: 'MAIN'}};
-        const newControls = {breakout: {sessionType: 'BREAKOUT'}};
-        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+        const oldLocus = {controls: {breakout: {sessionType: 'MAIN'}}};
+        const newLocus = {controls: {breakout: {sessionType: 'BREAKOUT'}}};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
           isReturnToMain: false, isJoinToBreakout: true
         });
       });
+
+      it('if needUseCache conditions are met, return isJoinToBreakout as true', () => {
+        const oldLocus = {
+          self: { isCreator: true },
+          controls: { breakout: { sessionType: BREAKOUTS.SESSION_TYPES.MAIN} },
+        };
+
+        const newLocus = {
+          participants: [
+            { isCreator: true, state: MEETING_STATE.STATES.JOINED },
+          ],
+          controls: {
+            breakout: {
+              sessionType: BREAKOUTS.SESSION_TYPES.MAIN,
+              groups: [{ id: 'group1' }]
+            },
+          },
+        };
+
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
+          isReturnToMain: true,
+          isJoinToBreakout: false
+        });
+      });
+
+      it('if needUseCache conditions are not met, return newLocus and isReturnToMain as false', () => {
+        const oldLocus = {
+          self: { isCreator: false },
+          controls: { breakout: { sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT} },
+        };
+
+        const newLocus = {
+          participants: [
+            { isCreator: true, state: MEETING_STATE.STATES.JOINED },
+          ],
+          controls: {
+            breakout: {
+              sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT,
+              groups: []
+            },
+          },
+        };
+
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
+          isReturnToMain: false,
+          isJoinToBreakout: false
+        });
+      });
     });
 
     describe('#isMainSessionDTO', () => {

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

@@ -111,6 +111,8 @@ describe('plugin-meetings', () => {
           },
           webcastControl: {streaming: false},
           practiceSession: {enabled: true},
+          annotationControl: {enabled: true},
+          rdcControl: {enabled: true},
         };
       });
 
@@ -278,6 +280,32 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('should trigger the CONTROLS_ANNOTATION_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_ANNOTATION_CHANGED,
+          {state: newControls.annotationControl}
+        );
+      });
+
+      it('should trigger the CONTROLS_REMOTE_DESKTOP_CONTROL_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_REMOTE_DESKTOP_CONTROL_CHANGED,
+          {state: newControls.rdcControl}
+        );
+      });
+
       it('should keep the recording state to `IDLE`', () => {
         locusInfo.controls = {
           record: {

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,7 @@ 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 +92,7 @@ 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 +155,12 @@ 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,
     });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
@@ -171,17 +168,13 @@ 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,
       },
       'meeting id'
     );
@@ -205,14 +198,75 @@ 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: []
+      },
+      '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,
+      },
+      '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,
+      },
+      '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)`, () => {
@@ -272,11 +326,39 @@ describe('createMediaConnection', () => {
     );
   });
 
+  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: [],
+      },
+      '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 RoapMediaConnection if ${testCase} (multistream disabled)`, () => {