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

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');
     });
@@ -285,7 +294,8 @@ describe('plugin-meetings', () => {
 
       describe('failure', () => {
         it('should not accept non-number input', () => {
-          const logUploadIntervalMultiplicationFactor = webex.meetings.config.logUploadIntervalMultiplicationFactor;
+          const logUploadIntervalMultiplicationFactor =
+            webex.meetings.config.logUploadIntervalMultiplicationFactor;
 
           webex.meetings._setLogUploadIntervalMultiplicationFactor('test');
           assert.equal(
@@ -390,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 () => {
@@ -441,6 +490,19 @@ describe('plugin-meetings', () => {
           assert.isTrue(webex.meetings.registered);
         });
 
+        it('resolves even if startReachability() rejects', async () => {
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+          webex.meetings.startReachability = sinon.stub().rejects(new Error('fake error'));
+
+          await webex.meetings.register();
+          assert.calledOnceWithExactly(webex.internal.device.register, undefined);
+          assert.called(webex.internal.services.getMeetingPreferences);
+          assert.called(webex.internal.services.fetchClientRegionInfo);
+          assert.called(webex.internal.mercury.connect);
+          assert.isTrue(webex.meetings.registered);
+        });
+
         it('passes on the device registration options', async () => {
           webex.canAuthorize = true;
           webex.meetings.registered = false;
@@ -569,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());
@@ -617,6 +697,7 @@ describe('plugin-meetings', () => {
             quality: 'LOW',
             authToken: 'fake_token',
             mirror: false,
+            canvasResolutionScaling: 1,
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
@@ -632,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);
@@ -666,7 +748,6 @@ describe('plugin-meetings', () => {
             audioContext: {},
             authToken: 'fake_token',
             mode: 'WORKLET',
-            env: 'prod',
             avoidSimd: false,
           });
           assert.exists(result.enable);
@@ -918,6 +999,69 @@ describe('plugin-meetings', () => {
           });
         });
       });
+      describe('#fetchStaticMeetingLink', () => {
+        const conversationUrl = 'conv.fakeconversationurl.com';
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('should have #fetchStaticMeetingLink', () => {
+          assert.exists(webex.meetings.fetchStaticMeetingLink);
+        });
+
+        it('should call MeetingInfo#fetchStaticMeetingLink() with proper params', () => {
+          webex.meetings.meetingInfo.fetchStaticMeetingLink = sinon
+            .stub()
+            .resolves(conversationUrl);
+
+          return webex.meetings.fetchStaticMeetingLink(conversationUrl).then(() => {
+            assert.calledWith(webex.meetings.meetingInfo.fetchStaticMeetingLink, conversationUrl);
+          });
+        });
+      });
+      describe('#enableStaticMeetingLink', () => {
+        const conversationUrl = 'conv.fakeconversationurl.com';
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('should have #enableStaticMeetingLink', () => {
+          assert.exists(webex.meetings.enableStaticMeetingLink);
+        });
+
+        it('should call MeetingInfo#enableStaticMeetingLink() with proper params', () => {
+          webex.meetings.meetingInfo.enableStaticMeetingLink = sinon
+            .stub()
+            .resolves(conversationUrl);
+
+          return webex.meetings.enableStaticMeetingLink(conversationUrl).then(() => {
+            assert.calledWith(webex.meetings.meetingInfo.enableStaticMeetingLink, conversationUrl);
+          });
+        });
+      });
+      describe('#disableStaticMeetingLink', () => {
+        const conversationUrl = 'conv.fakeconversationurl.com';
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('should have #disableStaticMeetingLink', () => {
+          assert.exists(webex.meetings.disableStaticMeetingLink);
+        });
+
+        it('should call MeetingInfo#disableStaticMeetingLink() with proper params', () => {
+          webex.meetings.meetingInfo.disableStaticMeetingLink = sinon
+            .stub()
+            .resolves(conversationUrl);
+
+          return webex.meetings.disableStaticMeetingLink(conversationUrl).then(() => {
+            assert.calledWith(webex.meetings.meetingInfo.disableStaticMeetingLink, conversationUrl);
+          });
+        });
+      });
       describe('#create', () => {
         let infoOptions;
 

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

@@ -50,6 +50,13 @@ describe('member', () => {
   
       assert.calledOnceWithExactly(MemberUtil.canReclaimHost, participant);
     });
+
+    it('checks that processParticipant calls isPresenterAssignmentProhibited', () => {
+      sinon.spy(MemberUtil, 'isPresenterAssignmentProhibited');
+      member.processParticipant(participant);
+  
+      assert.calledOnceWithExactly(MemberUtil.isPresenterAssignmentProhibited, participant);
+    });
   })
 
   describe('#processMember', () => {

package/test/unit/spec/member/util.js

@@ -557,6 +557,30 @@ describe('plugin-meetings', () => {
       testResult(false, undefined, false);
     });
   });
+
+  describe('MemberUtil.isPresenterAssignmentProhibited', () => {
+    it('returns true when isPresenterAssignmentProhibited is true', () => {
+      const participant = {
+        presenterAssignmentNotAllowed: true
+      };
+
+      assert.isTrue(MemberUtil.isPresenterAssignmentProhibited(participant));
+    });
+
+    it('returns false when isPresenterAssignmentProhibited is false', () => {
+      const participant = {
+        presenterAssignmentNotAllowed: false,
+      };
+
+      assert.isFalse(MemberUtil.isPresenterAssignmentProhibited(participant));
+    });
+
+    it('returns undefined when isPresenterAssignmentProhibited is undefined', () => {
+      const participant = {};
+
+      assert.isUndefined(MemberUtil.isPresenterAssignmentProhibited(participant));
+    });
+  });
 });
 
 describe('extractMediaStatus', () => {