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

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

@@ -169,26 +169,6 @@ describe('LocusMediaRequest.send()', () => {
     mockWebex.internal.newMetrics.submitClientEvent.resetHistory();
   };
 
-  const checkMetrics = (expectedMetrics: boolean = true) => {
-    if (expectedMetrics) {
-      assert.calledWith(mockWebex.internal.newMetrics.submitClientEvent, {
-        name: 'client.locus.media.request',
-        options: {
-          meetingId: 'meetingId',
-        },
-      });
-
-      assert.calledWith(mockWebex.internal.newMetrics.submitClientEvent, {
-        name: 'client.locus.media.response',
-        options: {
-          meetingId: 'meetingId',
-        },
-      });
-    } else {
-      assert.notCalled(mockWebex.internal.newMetrics.submitClientEvent);
-    }
-  };
-
   it('sends a roap message', async () => {
     const result = await sendRoapMessage('OFFER');
 
@@ -201,8 +181,6 @@ describe('LocusMediaRequest.send()', () => {
       upload: sinon.match.instanceOf(EventEmitter),
       download: sinon.match.instanceOf(EventEmitter),
     });
-
-    checkMetrics();
   });
 
   it('sends correct metric event when roap message fails', async () => {
@@ -232,8 +210,6 @@ describe('LocusMediaRequest.send()', () => {
       upload: sinon.match.instanceOf(EventEmitter),
       download: sinon.match.instanceOf(EventEmitter),
     });
-
-    checkMetrics(false);
   });
 
   it('sends a local mute request with sequence', async () => {
@@ -282,8 +258,6 @@ describe('LocusMediaRequest.send()', () => {
       upload: sinon.match.instanceOf(EventEmitter),
       download: sinon.match.instanceOf(EventEmitter),
     });
-
-    checkMetrics(false);
   });
 
   it('sends a local mute request with the last audio/video mute values', async () => {
@@ -303,8 +277,6 @@ describe('LocusMediaRequest.send()', () => {
       upload: sinon.match.instanceOf(EventEmitter),
       download: sinon.match.instanceOf(EventEmitter),
     });
-
-    checkMetrics(false);
   });
 
   it('sends only roap when roap and local mute are requested', async () => {
@@ -324,8 +296,6 @@ describe('LocusMediaRequest.send()', () => {
       upload: sinon.match.instanceOf(EventEmitter),
       download: sinon.match.instanceOf(EventEmitter),
     });
-
-    checkMetrics();
   });
 
   describe('queueing', () => {

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

@@ -2,7 +2,6 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import {createMuteState, MuteState} from '@webex/plugin-meetings/src/meeting/muteState';
-import PermissionError from '@webex/plugin-meetings/src/common/errors/permission';
 import {AUDIO, VIDEO} from '@webex/plugin-meetings/src/constants';
 
 import testUtils from '../../../utils/testUtils';
@@ -39,7 +38,6 @@ describe('plugin-meetings', () => {
       unmuteAllowed: true,
       remoteVideoMuted: false,
       unmuteVideoAllowed: true,
-
       locusInfo: {
         handleLocusDelta: sinon.stub(),
       },
@@ -778,5 +776,78 @@ describe('plugin-meetings', () => {
         })
       );
     });
+
+    describe('#enable', () => {
+      let locusLocalMuteStub;
+      let locusRemoteMuteStub;
+
+      const resetStubHistory = () => {
+        locusLocalMuteStub.resetHistory();
+        locusRemoteMuteStub.resetHistory();
+      };
+
+      beforeEach(async () => {
+        locusLocalMuteStub = MeetingUtil.remoteUpdateAudioVideo;
+        locusRemoteMuteStub = meeting.members.muteMember;
+
+        // initialise the MuteState with the stream
+        audio.handleLocalStreamChange(meeting);
+        await testUtils.flushPromises();
+
+        resetStubHistory();
+      });
+
+      it('does not do anything if current state is already the same', async () => {
+        // set it up so that we are remotely muted (so that a sync to server would do a remote unmute)
+        audio.handleServerRemoteMuteUpdate(meeting, true, true);
+
+        // audio is already enabled and we call to enable it again
+        audio.enable(meeting, true);
+        await testUtils.flushPromises();
+
+        // nothing should happen (especially no remote unmute)
+        assert.notCalled(locusRemoteMuteStub);
+        assert.notCalled(locusLocalMuteStub);
+
+        // now disable audio
+        audio.enable(meeting, false);
+        await testUtils.flushPromises();
+
+        resetStubHistory();
+
+        // disable it again
+        audio.enable(meeting, false);
+        await testUtils.flushPromises();
+
+        // nothing should happen
+        assert.notCalled(locusRemoteMuteStub);
+        assert.notCalled(locusLocalMuteStub);
+      });
+
+      it('does necessary local and remote mute changes when called with a new state', async () => {
+        // initial state is audio enabled with nothing muted
+
+        // now we disable audio
+        audio.enable(meeting, false);
+        await testUtils.flushPromises();
+
+        // so only a local mute should be done
+        assert.notCalled(locusRemoteMuteStub);
+        assert.calledWith(locusLocalMuteStub, meeting, true, undefined);
+
+        resetStubHistory();
+
+        // now simulate additionally a remote mute
+        audio.state.server.remoteMute = true;
+
+        // and enable audio back
+        audio.enable(meeting, true);
+        await testUtils.flushPromises();
+
+        // both local and remote unmute should be done
+        assert.calledWith(locusRemoteMuteStub, meeting.members.selfId, false, true);
+        assert.calledWith(locusLocalMuteStub, meeting, false, undefined);
+      });
+    });
   });
 });

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

@@ -1,4 +1,5 @@
 import 'jsdom-global/register';
+import {v4 as uuidv4} from 'uuid';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
@@ -205,7 +206,7 @@ describe('plugin-meetings', () => {
           roapMessage,
           reachability,
           permissionToken,
-          clientMediaPreferences
+          clientMediaPreferences,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -630,6 +631,36 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#setPostMeetingDataConsent', () => {
+      [true, false].forEach((consent) => {
+        it(`sends request to set post meeting data consent with ${consent}`, async () => {
+          const locusUrl = `https://locus-test.wbx2.com/locus/api/v1/loci/${consent}`;
+          const selfId = uuidv4();
+          const deviceUrl = `https://wdm-test.wbx2.com/wdm/api/v1/devices/${consent}`;
+
+          const consentPromise = meetingsRequest.setPostMeetingDataConsent({
+            postMeetingDataConsent: consent,
+            locusUrl,
+            selfId,
+            deviceUrl,
+          });
+          assert.exists(consentPromise.then);
+          await consentPromise;
+
+          checkRequest({
+            method: 'PATCH',
+            uri: `${locusUrl}/participant/${selfId}/controls`,
+            body: {
+              consent: {
+                postMeetingDataConsent: consent,
+                deviceUrl,
+              },
+            },
+          });
+        });
+      });
+    });
+
     describe('#prepareLeaveMeetingRequestOptions', () => {
       it('returns expected result', async () => {
         const result = meetingsRequest.prepareLeaveMeetingRequestOptions({

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

@@ -66,7 +66,7 @@ describe('plugin-meetings', () => {
 
     describe('#cleanup', () => {
       it('do clean up on meeting object with LLM enabled', async () => {
-        meeting.config = {enableAutomaticLLM : true};
+        meeting.config = {enableAutomaticLLM: true};
         await MeetingUtil.cleanUp(meeting);
         assert.calledOnce(meeting.cleanupLocalStreams);
         assert.calledOnce(meeting.closeRemoteStreams);
@@ -84,7 +84,7 @@ describe('plugin-meetings', () => {
       });
 
       it('do clean up on meeting object with LLM disabled', async () => {
-        meeting.config = {enableAutomaticLLM : false};
+        meeting.config = {enableAutomaticLLM: false};
         await MeetingUtil.cleanUp(meeting);
         assert.calledOnce(meeting.cleanupLocalStreams);
         assert.calledOnce(meeting.closeRemoteStreams);
@@ -392,8 +392,7 @@ describe('plugin-meetings', () => {
           meetingJoinUrl: 'meetingJoinUrl',
           locusUrl: 'locusUrl',
           meetingRequest: {
-            joinMeeting: sinon.stub().returns(
-              Promise.resolve(joinMeetingResponse)),
+            joinMeeting: sinon.stub().returns(Promise.resolve(joinMeetingResponse)),
           },
           getWebexObject: sinon.stub().returns(webex),
           setLocus: sinon.stub(),
@@ -410,23 +409,29 @@ describe('plugin-meetings', () => {
           id: 'fake client media preferences',
         };
 
-        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
-        webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(
+          FAKE_REACHABILITY_REPORT
+        );
+        webex.meetings.reachability.getClientMediaPreferences.resolves(
+          FAKE_CLIENT_MEDIA_PREFERENCES
+        );
 
-        sinon
-          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
-          .get(() => true);
-        sinon
-          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
-          .get(() => true);
+        sinon.stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4').get(() => true);
+        sinon.stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6').get(() => true);
 
         await MeetingUtil.joinMeeting(meeting, {
           reachability: 'reachability',
           roapMessage: 'roapMessage',
         });
 
-        assert.calledOnceWithExactly(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
-        assert.calledOnceWithExactly(webex.meetings.reachability.getClientMediaPreferences, meeting.isMultistream, IP_VERSION.ipv4_and_ipv6);
+        assert.calledOnceWithExactly(
+          webex.meetings.reachability.getReachabilityReportToAttachToRoap
+        );
+        assert.calledOnceWithExactly(
+          webex.meetings.reachability.getClientMediaPreferences,
+          meeting.isMultistream,
+          IP_VERSION.ipv4_and_ipv6
+        );
 
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
@@ -436,9 +441,9 @@ describe('plugin-meetings', () => {
         assert.equal(parameter.clientMediaPreferences, FAKE_CLIENT_MEDIA_PREFERENCES);
         assert.equal(parameter.roapMessage, 'roapMessage');
 
-        assert.calledOnce(meeting.setLocus)
+        assert.calledOnce(meeting.setLocus);
         const setLocusParameter = meeting.setLocus.getCall(0).args[0];
-        assert.deepEqual(setLocusParameter, MeetingUtil.parseLocusJoin(joinMeetingResponse))
+        assert.deepEqual(setLocusParameter, MeetingUtil.parseLocusJoin(joinMeetingResponse));
 
         assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
           name: 'client.locus.join.request',
@@ -460,7 +465,6 @@ describe('plugin-meetings', () => {
         });
       });
 
-
       it('#Should call `meetingRequest.joinMeeting and handle a date header in the response : isoLocalClientMeetingJoinedTime', async () => {
         meeting.isMultistream = true;
 
@@ -471,30 +475,30 @@ describe('plugin-meetings', () => {
           id: 'fake client media preferences',
         };
 
-        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
-        webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(
+          FAKE_REACHABILITY_REPORT
+        );
+        webex.meetings.reachability.getClientMediaPreferences.resolves(
+          FAKE_CLIENT_MEDIA_PREFERENCES
+        );
 
-        sinon
-          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
-          .get(() => true);
-        sinon
-          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
-          .get(() => true);
+        sinon.stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4').get(() => true);
+        sinon.stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6').get(() => true);
 
         meeting.meetingRequest.joinMeeting.resolves({
           headers: {
-            date: 'test'
+            date: 'test',
           },
           body: {
             mediaConnections: [{mediaId: 'test'}],
             locus: {
               url: 'test',
               self: {
-                id: 'test'
-              }
-            }
-          }
-        })
+                id: 'test',
+              },
+            },
+          },
+        });
 
         await MeetingUtil.joinMeeting(meeting, {
           reachability: 'reachability',
@@ -740,6 +744,18 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('requiresPostMeetingDataConsentPrompt', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.requiresPostMeetingDataConsentPrompt([
+            'SHOW_POST_MEETING_DATA_CONSENT_PROMPT',
+          ]),
+          true
+        );
+        assert.deepEqual(MeetingUtil.requiresPostMeetingDataConsentPrompt([]), false);
+      });
+    });
+
     describe('canUserRenameOthers', () => {
       it('works as expected', () => {
         assert.deepEqual(MeetingUtil.canUserRenameOthers(['CAN_RENAME_OTHERS']), true);
@@ -749,8 +765,38 @@ describe('plugin-meetings', () => {
 
     describe('canShareWhiteBoard', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canShareWhiteBoard(['SHARE_WHITEBOARD']), true);
-        assert.deepEqual(MeetingUtil.canShareWhiteBoard([]), false);
+        assert.deepEqual(
+          MeetingUtil.canShareWhiteBoard(['SHARE_WHITEBOARD'], {
+            [SELF_POLICY.SUPPORT_WHITEBOARD]: true,
+          }),
+          true
+        );
+        assert.deepEqual(
+          MeetingUtil.canShareWhiteBoard([], {
+            [SELF_POLICY.SUPPORT_WHITEBOARD]: true,
+          }),
+          false
+        );
+        assert.deepEqual(
+          MeetingUtil.canShareWhiteBoard(['SHARE_WHITEBOARD'], {
+            [SELF_POLICY.SUPPORT_WHITEBOARD]: false,
+          }),
+          false
+        );
+        assert.deepEqual(
+          MeetingUtil.canShareWhiteBoard([], {
+            [SELF_POLICY.SUPPORT_WHITEBOARD]: false,
+          }),
+          false
+        );
+        assert.deepEqual(MeetingUtil.canShareWhiteBoard(['SHARE_WHITEBOARD'], undefined), false);
+      });
+    });
+
+    describe('canMoveToLobby', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canMoveToLobby(['MOVE_TO_LOBBY']), true);
+        assert.deepEqual(MeetingUtil.canMoveToLobby([]), false);
       });
     });
 

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -511,6 +511,7 @@ describe('plugin-meetings', () => {
             password: 'abc',
             captchaID: '999',
             captchaVerifyCode: 'aabbcc11',
+            disableWebRedirect: true,
           },
         });
         assert.deepEqual(result, requestResponse);
@@ -544,6 +545,7 @@ describe('plugin-meetings', () => {
             supportCountryList: true,
             meetingKey: '1234323',
             installedOrgID,
+            disableWebRedirect: true,
           },
         });
         assert.deepEqual(result, requestResponse);
@@ -578,6 +580,7 @@ describe('plugin-meetings', () => {
             supportCountryList: true,
             meetingKey: '1234323',
             locusId,
+            disableWebRedirect: true,
           },
         });
         assert.deepEqual(result, requestResponse);
@@ -613,6 +616,7 @@ describe('plugin-meetings', () => {
             supportCountryList: true,
             meetingKey: '1234323',
             ...extraParams,
+            disableWebRedirect: true,
           },
         });
         assert.deepEqual(result, requestResponse);
@@ -843,6 +847,7 @@ describe('plugin-meetings', () => {
                 supportCountryList: true,
                 meetingKey: '1234323',
                 ...extraParams,
+                disableWebRedirect: true,
               },
             });
             assert.deepEqual(result, requestResponse);
@@ -922,6 +927,7 @@ describe('plugin-meetings', () => {
             supportCountryList: true,
             meetingKey: '1234323',
             ...extraParams,
+            disableWebRedirect: true,
           },
         });
         assert.deepEqual(result, requestResponse);
@@ -1065,6 +1071,41 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('should stop call fetchMeetingInfo if siteFullUrl is empty for 404 response', () => {
+
+        const runTest = async (wbxAppApiCode, expectedIsPasswordRequired) => {
+          webex.request = sinon.stub().rejects({
+            statusCode: 404,
+            body: {
+              code: wbxAppApiCode,
+              message: 'Alternate Meeting Server',
+              data: {
+                'siteFullUrl': ''
+              }
+            },
+          });
+
+
+          try {
+            await meetingInfo.fetchMeetingInfo('1234323', DESTINATION_TYPE.MEETING_ID, 'abc', {
+              id: '999',
+              code: 'aabbcc11',
+            });
+            assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+          } catch (err) {
+            assert(Metrics.sendBehavioralMetric.calledOnce);
+            assert.deepEqual(err.body.data, {
+              siteFullUrl: ''
+            });
+          }
+        };
+
+        it('should throw MeetingInfoV2CaptchaError for 404 response (wbxappapi code 404100)', async () => {
+          await runTest(404100, false);
+        });
+      });
+
+
       it('should throw an error and not fetch with an "empty" body', async () => {
         const body = {supportHostKey: 'foo', supportCountryList: 'bar'};
         const requestResponse = {statusCode: 200, body};

package/test/unit/spec/meeting-info/utilv2.js

@@ -241,6 +241,25 @@ describe('plugin-meetings', () => {
           }
         );
       });
+
+      it('allows for disableWebRedirect', () => {
+
+        const res = MeetingInfoUtil.getRequestBody({
+          type: DESTINATION_TYPE.CONVERSATION_URL,
+          destination: 'https://conv-a.wbx2.com/conversation/api/v1/conversations/bfb49281',
+          disableWebRedirect: true,
+        });
+
+        assert.deepEqual(
+          res,
+          {
+            conversationUrl: 'https://conv-a.wbx2.com/conversation/api/v1/conversations/bfb49281',
+            supportHostKey: true,
+            supportCountryList: true,
+            disableWebRedirect: true,
+          }
+        );
+      });
     });
 
     describe('#getWebexSite', () => {

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

@@ -182,6 +182,15 @@ describe('plugin-meetings', () => {
         metrics: {
           submitClientMetrics: sinon.stub().returns(Promise.resolve()),
         },
+        newMetrics: {
+          submitClientEvent: sinon.stub(),
+          callDiagnosticLatencies: {
+            measureLatency: sinon.stub().returns(Promise.resolve()),
+          },
+          callDiagnosticMetrics: {
+            clearErrorCache: sinon.stub(),
+          },
+        },
       });
       webex.emit('ready');
     });
@@ -391,6 +400,45 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleDisableAudioMainDtx', () => {
+      it('should have _toggleDisableAudioMainDtx', () => {
+        assert.equal(typeof webex.meetings._toggleDisableAudioMainDtx, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to disable audio main dtx', () => {
+          webex.meetings._toggleDisableAudioMainDtx(true);
+          assert.equal(webex.meetings.config.experimental.disableAudioMainDtx, true);
+        });
+      });
+    });
+
+    describe('#_toggleEnableAudioTwccForMultistream', () => {
+      it('should have _toggleEnableAudioTwccForMultistream', () => {
+        assert.equal(typeof webex.meetings._toggleEnableAudioTwccForMultistream, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to enable audio twcc support', () => {
+          webex.meetings._toggleEnableAudioTwccForMultistream(true);
+          assert.equal(webex.meetings.config.enableAudioTwccForMultistream, true);
+        });
+      });
+    });
+
+    describe('#_toggleStopIceGatheringAfterFirstRelayCandidate', () => {
+      it('should have _toggleStopIceGatheringAfterFirstRelayCandidate', () => {
+        assert.equal(typeof webex.meetings._toggleStopIceGatheringAfterFirstRelayCandidate, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to stop ICE candidates gathering after first relay candidate', () => {
+          webex.meetings._toggleStopIceGatheringAfterFirstRelayCandidate(true);
+          assert.equal(webex.meetings.config.stopIceGatheringAfterFirstRelayCandidate, true);
+        });
+      });
+    });
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', async () => {
@@ -583,6 +631,24 @@ describe('plugin-meetings', () => {
           await assert.isRejected(webex.meetings.unregister());
         });
 
+        it('does not reject when device.unregister fails with statusCode 404', (done) => {
+          webex.meetings.registered = true;
+          webex.internal.device.unregister = sinon.stub().rejects({statusCode: 404});
+          webex.meetings.unregister().then(() => {
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meetings),
+              {
+                file: 'meetings',
+                function: 'unregister',
+              },
+              'meetings:unregistered'
+            );
+            assert.isFalse(webex.meetings.registered);
+            done();
+          });
+        });
+
         it('rejects when mercury.disconnect fails', async () => {
           webex.meetings.registered = true;
           webex.internal.mercury.disconnect = sinon.stub().returns(Promise.reject());
@@ -631,6 +697,7 @@ describe('plugin-meetings', () => {
             quality: 'LOW',
             authToken: 'fake_token',
             mirror: false,
+            canvasResolutionScaling: 1,
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
@@ -646,6 +713,7 @@ describe('plugin-meetings', () => {
             quality: 'HIGH',
             blurStrength: 'STRONG',
             bgImageUrl: 'https://test.webex.com/landscape.5a535788.jpg',
+            canvasResolutionScaling: 1,
           };
 
           const result = await webex.meetings.createVirtualBackgroundEffect(effectOptions);
@@ -680,7 +748,6 @@ describe('plugin-meetings', () => {
             audioContext: {},
             authToken: 'fake_token',
             mode: 'WORKLET',
-            env: 'prod',
             avoidSimd: false,
           });
           assert.exists(result.enable);