@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

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

@@ -1,22 +1,55 @@
-import * as internalMediaModule from '@webex/plugin-meetings/src/media/internal-media-core-wrapper';
+import * as internalMediaModule from '@webex/internal-media-core';
 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 {forEach} from 'lodash';
+import MockWebex from '@webex/test-helper-mock-webex';
 
 describe('createMediaConnection', () => {
+  let clock;
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+  });
+  const webex = MockWebex();
+
   const fakeRoapMediaConnection = {
     id: 'roap media connection',
   };
-  const fakeAudioTrack = {
-    id: 'audio track',
+  const fakeTrack = {
+    id: 'any fake track'
+  }
+  const fakeAudioStream = {
+    outputStream: {
+      getTracks: () => {
+        return [fakeTrack];
+      }
+    }
   };
-  const fakeVideoTrack = {
-    id: 'video track',
+  const fakeVideoStream = {
+    outputStream: {
+      getTracks: () => {
+        return [fakeTrack];
+      }
+    }
+  };
+  const fakeShareVideoStream = {
+    outputStream: {
+      getTracks: () => {
+        return [fakeTrack];
+      }
+    }
+  };
+  const fakeShareAudioStream = {
+    outputStream: {
+      getTracks: () => {
+        return [fakeTrack];
+      }
+    }
   };
-
   afterEach(() => {
     sinon.restore();
+    clock.uninstall()
   });
 
   it('creates a RoapMediaConnection when multistream is disabled', () => {
@@ -29,32 +62,30 @@ describe('createMediaConnection', () => {
     const ENABLE_EXTMAP = false;
     const ENABLE_RTX = true;
 
-    Media.createMediaConnection(
-      {
+    Media.createMediaConnection(false, 'some debug id', webex, 'meetingId', 'correlationId', {
+      mediaProperties: {
         mediaDirection: {
-          sendAudio: true,
+          sendAudio: false,
           sendVideo: true,
           sendShare: false,
-          receiveAudio: true,
+          receiveAudio: false,
           receiveVideo: true,
           receiveShare: true,
         },
-        audioTrack: fakeAudioTrack,
-        videoTrack: fakeVideoTrack,
-        shareTrack: null,
+        audioStream: fakeAudioStream,
+        videoStream: fakeVideoStream,
+        shareVideoTrack: null,
+        shareAudioTrack: null,
       },
-      {
-        isMultistream: false,
-        remoteQualityLevel: 'HIGH',
-        enableRtx: ENABLE_RTX,
-        enableExtmap: ENABLE_EXTMAP,
-        turnServerInfo: {
-          url: 'turn server url',
-          username: 'turn username',
-          password: 'turn password',
-        },
-      }
-    );
+      remoteQualityLevel: 'HIGH',
+      enableRtx: ENABLE_RTX,
+      enableExtmap: ENABLE_EXTMAP,
+      turnServerInfo: {
+        url: 'turn server url',
+        username: 'turn username',
+        password: 'turn password',
+      },
+    });
     assert.calledOnce(roapMediaConnectionConstructorStub);
     assert.calledWith(
       roapMediaConnectionConstructorStub,
@@ -82,19 +113,20 @@ describe('createMediaConnection', () => {
         },
       },
       {
-        send: {
-          audio: fakeAudioTrack,
-          video: fakeVideoTrack,
-          screenShareVideo: null,
+        localTracks: {
+          audio: fakeTrack,
+          video: fakeTrack,
+          screenShareVideo: undefined,
+          screenShareAudio: undefined,
         },
-        receive: {
-          audio: true,
-          video: true,
-          screenShareVideo: true,
-          remoteQualityLevel: 'HIGH',
+        direction: {
+          audio: 'inactive',
+          video: 'sendrecv',
+          screenShareVideo: 'recvonly',
         },
+        remoteQualityLevel: 'HIGH',
       },
-      'mc'
+      'some debug id'
     );
   });
 
@@ -103,17 +135,24 @@ describe('createMediaConnection', () => {
       .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
-    Media.createMediaConnection(
-      {},
-      {
-        isMultistream: true,
-        turnServerInfo: {
-          url: 'turn server url',
-          username: 'turn username',
-          password: 'turn password',
+    Media.createMediaConnection(true, 'some debug id', webex, 'meeting id', 'correlationId', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
         },
-      }
-    );
+      },
+      turnServerInfo: {
+        url: 'turn server url',
+        username: 'turn username',
+        password: 'turn password',
+      },
+      bundlePolicy: 'max-bundle',
+    });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
       multistreamRoapMediaConnectionConstructorStub,
@@ -125,99 +164,143 @@ describe('createMediaConnection', () => {
             credential: 'turn password',
           },
         ],
+        bundlePolicy: 'max-bundle',
       },
-      'mc'
+      'meeting id'
     );
   });
 
-  it('passes empty ICE servers array to MultistreamRoapMediaConnection if turnServerInfo is undefined (multistream enabled)', () => {
+  [
+    {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
+    {testCase: 'turnServerInfo.url is empty string', turnServerInfo: {url: '', username: 'turn username', password: 'turn password'}},
+  ].forEach(({testCase, turnServerInfo}) => {
+    it(`passes empty ICE servers array to MultistreamRoapMediaConnection if ${testCase} (multistream enabled)`, () => {
+      const multistreamRoapMediaConnectionConstructorStub = sinon
+        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .returns(fakeRoapMediaConnection);
+  
+      Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: false,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
+          },
+        },
+        turnServerInfo,
+      });
+      assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+      assert.calledWith(
+        multistreamRoapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+        },
+        'meeting id'
+        );
+    });
+  });
+      
+  it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
       .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
-    Media.createMediaConnection(
-      {},
-      {
-        isMultistream: true,
-        turnServerInfo: undefined,
-      }
-    );
+    Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+      bundlePolicy: undefined,
+    });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
       multistreamRoapMediaConnectionConstructorStub,
       {
         iceServers: [],
       },
-      'mc'
+      'meeting id'
     );
   });
 
-  it('passes empty ICE servers array to RoapMediaConnection if turnServerInfo is undefined (multistream disabled)', () => {
-    const roapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'RoapMediaConnection')
-      .returns(fakeRoapMediaConnection);
+  [
+    {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
+    {testCase: 'turnServerInfo.url is empty string', turnServerInfo: {url: '', username: 'turn username', password: 'turn password'}},
+  ].forEach(({testCase, turnServerInfo}) => {
+    it(`passes empty ICE servers array to RoapMediaConnection if ${testCase} (multistream disabled)`, () => {
+      const roapMediaConnectionConstructorStub = sinon
+        .stub(internalMediaModule, 'RoapMediaConnection')
+        .returns(fakeRoapMediaConnection);
 
-    StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
+      StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
 
-    const ENABLE_EXTMAP = false;
-    const ENABLE_RTX = true;
+      const ENABLE_EXTMAP = false;
+      const ENABLE_RTX = true;
 
-    Media.createMediaConnection(
-      {
-        mediaDirection: {
-          sendAudio: true,
-          sendVideo: true,
-          sendShare: true,
-          receiveAudio: true,
-          receiveVideo: true,
-          receiveShare: true,
+      Media.createMediaConnection(false, 'some debug id', webex, 'meeting id', 'correlationId', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: true,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
+          },
+          audioStream: fakeAudioStream,
+          videoStream: null,
+          shareVideoStream: fakeShareVideoStream,
+          shareAudioStream: fakeShareAudioStream,
         },
-        audioTrack: fakeAudioTrack,
-        videoTrack: null,
-        shareTrack: fakeVideoTrack,
-      },
-      {
-        isMultistream: false,
         remoteQualityLevel: 'HIGH',
         enableRtx: ENABLE_RTX,
         enableExtmap: ENABLE_EXTMAP,
-        turnServerInfo: undefined,
-      }
-    );
-    assert.calledOnce(roapMediaConnectionConstructorStub);
-    assert.calledWith(
-      roapMediaConnectionConstructorStub,
-      {
-        iceServers: [],
-        skipInactiveTransceivers: false,
-        requireH264: true,
-        sdpMunging: {
-          convertPort9to0: false,
-          addContentSlides: true,
-          bandwidthLimits: {
-            audio: 123,
-            video: 456,
+        turnServerInfo,
+      });
+      assert.calledOnce(roapMediaConnectionConstructorStub);
+      assert.calledWith(
+        roapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+          skipInactiveTransceivers: false,
+          requireH264: true,
+          sdpMunging: {
+            convertPort9to0: false,
+            addContentSlides: true,
+            bandwidthLimits: {
+              audio: 123,
+              video: 456,
+            },
+            startBitrate: 999,
+            periodicKeyframes: 20,
+            disableExtmap: !ENABLE_EXTMAP,
+            disableRtx: !ENABLE_RTX,
           },
-          startBitrate: 999,
-          periodicKeyframes: 20,
-          disableExtmap: !ENABLE_EXTMAP,
-          disableRtx: !ENABLE_RTX,
         },
-      },
-      {
-        send: {
-          audio: fakeAudioTrack,
-          video: null,
-          screenShareVideo: fakeVideoTrack,
-        },
-        receive: {
-          audio: true,
-          video: true,
-          screenShareVideo: true,
+        {
+          localTracks: {
+            audio: fakeTrack,
+            video: undefined,
+            screenShareVideo: fakeTrack,
+            screenShareAudio: fakeTrack,
+          },
+          direction: {
+            audio: 'sendrecv',
+            video: 'sendrecv',
+            screenShareVideo: 'sendrecv',
+          },
           remoteQualityLevel: 'HIGH',
         },
-      },
-      'mc'
-    );
+        'some debug id'
+      );
+    });
   });
 });

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

@@ -1,10 +1,10 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState, Event} from '@webex/internal-media-core';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import testUtils from '../../../utils/testUtils';
-import {PC_BAIL_TIMEOUT} from '@webex/plugin-meetings/src/constants';
+import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import {Defer} from '@webex/common';
 
 describe('MediaProperties', () => {
@@ -19,7 +19,7 @@ describe('MediaProperties', () => {
       getStats: sinon.stub().resolves([]),
       on: sinon.stub(),
       off: sinon.stub(),
-      getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+      getConnectionState: sinon.stub().returns(ConnectionState.Connected),
     };
 
     mediaProperties = new MediaProperties();
@@ -35,7 +35,7 @@ describe('MediaProperties', () => {
       await mediaProperties.waitForMediaConnectionConnected();
     });
     it('rejects after timeout if ice state does not reach connected/completed', async () => {
-      mockMC.getConnectionState.returns(MC.ConnectionState.Connecting);
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
 
       let promiseResolved = false;
       let promiseRejected = false;
@@ -52,7 +52,7 @@ describe('MediaProperties', () => {
       assert.equal(promiseResolved, false);
       assert.equal(promiseRejected, false);
 
-      await clock.tickAsync(PC_BAIL_TIMEOUT);
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
       await testUtils.flushPromises();
 
       assert.equal(promiseResolved, false);
@@ -60,15 +60,15 @@ describe('MediaProperties', () => {
 
       // check that listener was registered and removed
       assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], MC.Event.CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, MC.Event.CONNECTION_STATE_CHANGED, listener);
+      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
     });
 
     it(`resolves when media connection reaches "connected" state`, async () => {
-      mockMC.getConnectionState.returns(MC.ConnectionState.Connecting);
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
 
       const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
 
@@ -89,11 +89,11 @@ describe('MediaProperties', () => {
 
       // check the right listener was registered
       assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], MC.Event.CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       // call the listener and pretend we are now connected
-      mockMC.getConnectionState.returns(MC.ConnectionState.Connected);
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
       listener();
       await testUtils.flushPromises();
 
@@ -102,7 +102,7 @@ describe('MediaProperties', () => {
 
       // check that listener was removed
       assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, MC.Event.CONNECTION_STATE_CHANGED, listener);
+      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
 
       assert.calledOnce(clearTimeoutSpy);
     });

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -1,7 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import InMeetingActions from '@webex/plugin-meetings/src/meeting/in-meeting-actions';
 
-
 describe('plugin-meetings', () => {
   describe('in-meeting-actions', () => {
     const checkValues = (actions, expected?) => {
@@ -11,9 +10,17 @@ describe('plugin-meetings', () => {
         canLock: null,
         canUnlock: null,
         canAssignHost: null,
+        canSetPresenter: null,
+        canUnsetPresenter: null,
         canStartRecording: null,
         canPauseRecording: null,
         canResumeRecording: null,
+        canSetMuteOnEntry: null,
+        canUnsetMuteOnEntry: null,
+        canSetDisallowUnmute: null,
+        canUnsetDisallowUnmute: null,
+        canSetMuted: null,
+        canUnsetMuted: null,
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,
@@ -23,12 +30,52 @@ describe('plugin-meetings', () => {
         canStartTranscribing: null,
         canStopTranscribing: null,
         isClosedCaptionActive: null,
+        isSaveTranscriptsEnabled: null,
         isWebexAssistantActive: null,
         canViewCaptionPanel: null,
         isRealTimeTranslationEnabled: null,
         canSelectSpokenLanguages: null,
         waitingForOthersToJoin: null,
-        ...expected
+        canSendReactions: null,
+        canManageBreakout: null,
+        canBroadcastMessageToBreakout: null,
+        canAdmitLobbyToBreakout: null,
+        canUserAskForHelp: null,
+        canUserRenameSelfAndObserved: null,
+        canUserRenameOthers: null,
+        isBreakoutPreassignmentsEnabled: null,
+        canMuteAll: null,
+        canUnmuteAll: null,
+        canEnableHardMute: null,
+        canDisableHardMute: null,
+        canEnableMuteOnEntry: null,
+        canDisableMuteOnEntry: null,
+        canEnableReactions: null,
+        canDisableReactions: null,
+        canEnableReactionDisplayNames: null,
+        canDisableReactionDisplayNames: null,
+        canUpdateShareControl: null,
+        canEnableViewTheParticipantsList: null,
+        canDisableViewTheParticipantsList: null,
+        canEnableRaiseHand: null,
+        canDisableRaiseHand: null,
+        canEnableVideo: null,
+        canDisableVideo: null,
+        canShareFile: null,
+        canShareApplication: null,
+        canShareCamera: null,
+        canShareDesktop: null,
+        canShareContent: null,
+        canTransferFile: null,
+        canChat: null,
+        canDoVideo: null,
+        canAnnotate: null,
+        canUseVoip: null,
+        supportHQV: null,
+        supportHDV: null,
+        canShareWhiteBoard: null,
+        enforceVirtualBackground: null,
+        ...expected,
       };
 
       // Check get retuns all the correct values at once
@@ -46,10 +93,16 @@ describe('plugin-meetings', () => {
       'canLock',
       'canUnlock',
       'canAssignHost',
+      'canSetPresenter',
+      'canUnsetPresenter',
       'canStartRecording',
       'canPauseRecording',
       'canResumeRecording',
       'canStopRecording',
+      'canSetMuteOnEntry',
+      'canUnsetMuteOnEntry',
+      'canSetDisallowUnmute',
+      'canUnsetDisallowUnmute',
       'canRaiseHand',
       'canLowerAllHands',
       'canLowerSomeoneElsesHand',
@@ -57,11 +110,51 @@ describe('plugin-meetings', () => {
       'canEnableClosedCaption',
       'canStopTranscribing',
       'isClosedCaptionActive',
+      'isSaveTranscriptsEnabled',
       'isWebexAssistantActive',
       'canViewCaptionPanel',
       'isRealTimeTranslationEnabled',
       'canSelectSpokenLanguages',
-      'waitingForOthersToJoin'
+      'waitingForOthersToJoin',
+      'canSendReactions',
+      'canManageBreakout',
+      'canBroadcastMessageToBreakout',
+      'canAdmitLobbyToBreakout',
+      'canUserAskForHelp',
+      'canUserRenameSelfAndObserved',
+      'canUserRenameOthers',
+      'isBreakoutPreassignmentsEnabled',
+      'canMuteAll',
+      'canUnmuteAll',
+      'canEnableHardMute',
+      'canDisableHardMute',
+      'canEnableMuteOnEntry',
+      'canDisableMuteOnEntry',
+      'canEnableReactions',
+      'canDisableReactions',
+      'canEnableReactionDisplayNames',
+      'canDisableReactionDisplayNames',
+      'canUpdateShareControl',
+      'canEnableViewTheParticipantsList',
+      'canDisableViewTheParticipantsList',
+      'canEnableRaiseHand',
+      'canDisableRaiseHand',
+      'canEnableVideo',
+      'canDisableVideo',
+      'canShareFile',
+      'canShareApplication',
+      'canShareCamera',
+      'canShareDesktop',
+      'canShareContent',
+      'canTransferFile',
+      'canChat',
+      'canDoVideo',
+      'canAnnotate',
+      'canUseVoip',
+      'supportHQV',
+      'supportHDV',
+      'canShareWhiteBoard',
+      'enforceVirtualBackground',
     ].forEach((key) => {
       it(`get and set for ${key} work as expected`, () => {
         const inMeetingActions = new InMeetingActions();