@webex/plugin-meetings 3.8.0-next.8 → 3.8.0-next.80

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', () => {

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

@@ -120,9 +120,9 @@ describe('plugin-meetings', () => {
       meeting = {
         request: sinon.mock().returns(Promise.resolve()),
         locusInfo: {
-          sequence: {}
-        }
-      }
+          sequence: {},
+        },
+      };
 
       createMembers = (options) => new Members({locusUrl: options.url, meeting}, {parent: webex});
     });
@@ -157,6 +157,17 @@ describe('plugin-meetings', () => {
 
         assert.isRejected(members.addMember({email: 'test@cisco.com'}));
       });
+
+      it('should accept valid SIP email addresses', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+
+        const members = createMembers({url: true});
+        
+        await members.addMember({email: 'sip:test@cisco.com'});
+        
+        assert.calledOnce(MembersUtil.isInvalidInvitee);
+        assert.isFalse(MembersUtil.isInvalidInvitee({email: 'sip:test@cisco.com'}), 'SIP email should be valid');
+      });
     });
 
     describe('#admitMembers', () => {
@@ -342,6 +353,32 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#cancelSIPInvite', () => {
+      const memberId = uuid.v4();
+      it('should invoke cancelSIPInviteOptions from MembersUtil when cancelSIPInvite is called with valid params', async () => {
+        sandbox.spy(MembersUtil, 'cancelSIPInviteOptions');
+
+        const members = createMembers({url: url1});
+
+        await members.cancelSIPInvite({memberId});
+        assert.calledOnce(MembersUtil.cancelSIPInviteOptions);
+      });
+
+      it('should throw a rejection if there is no locus url', async () => {
+        const members = createMembers({url: false});
+
+        assert.isRejected(members.cancelSIPInvite({memberId}));
+      });
+      
+      it('should throw a rejection if memberId is not provided', async () => {
+        const members = createMembers({url: url1});
+
+        assert.isRejected(members.cancelSIPInvite({}));
+        assert.isRejected(members.cancelSIPInvite({memberId: null}));
+        assert.isRejected(members.cancelSIPInvite({memberId: undefined}));
+      });
+    });
+
     describe('#assignRoles', () => {
       const fakeRoles = [
         {type: 'PRESENTER', hasRole: true},
@@ -349,7 +386,7 @@ describe('plugin-meetings', () => {
         {type: 'COHOST', hasRole: true},
       ];
 
-      const resolvedValue = "it worked";
+      const resolvedValue = 'it worked';
 
       const genericMessage = 'Generic error from the API';
 
@@ -364,9 +401,13 @@ describe('plugin-meetings', () => {
         };
 
         if (errorCode) {
-          spies.assignRolesMember = sandbox.stub(members.membersRequest, 'assignRolesMember').rejects({body: {errorCode}, message: genericMessage});
+          spies.assignRolesMember = sandbox
+            .stub(members.membersRequest, 'assignRolesMember')
+            .rejects({body: {errorCode}, message: genericMessage});
         } else {
-          spies.assignRolesMember = sandbox.stub(members.membersRequest, 'assignRolesMember').resolves(resolvedValue);
+          spies.assignRolesMember = sandbox
+            .stub(members.membersRequest, 'assignRolesMember')
+            .resolves(resolvedValue);
         }
 
         return {members, spies};
@@ -378,7 +419,15 @@ describe('plugin-meetings', () => {
         assert.notCalled(spies.assignRolesMember);
       };
 
-      const checkError = async (error, expectedMemberId, expectedRoles, expectedLocusUrl, resultPromise, expectedMessage, spies) => {
+      const checkError = async (
+        error,
+        expectedMemberId,
+        expectedRoles,
+        expectedLocusUrl,
+        resultPromise,
+        expectedMessage,
+        spies
+      ) => {
         await assert.isRejected(resultPromise, error, expectedMessage);
         assert.calledOnceWithExactly(
           spies.generateRoleAssignmentMemberOptions,
@@ -423,7 +472,7 @@ describe('plugin-meetings', () => {
         await checkInvalid(
           resultPromise,
           'The member id must be defined to assign the roles to a member.',
-          spies,
+          spies
         );
       });
 
@@ -435,7 +484,7 @@ describe('plugin-meetings', () => {
         await checkInvalid(
           resultPromise,
           'The associated locus url for this meetings members object must be defined.',
-          spies,
+          spies
         );
       });
 
@@ -452,7 +501,7 @@ describe('plugin-meetings', () => {
           url1,
           resultPromise,
           'Non converged meetings, PSTN or SIP users in converged meetings are not supported currently.',
-          spies,
+          spies
         );
       });
 
@@ -469,7 +518,7 @@ describe('plugin-meetings', () => {
           url1,
           resultPromise,
           'Reclaim Host Role Not Allowed For Other Participants. Participants cannot claim host role in PMR meeting, space instant meeting or escalated instant meeting. However, the original host still can reclaim host role when it manually makes another participant to be the host.',
-          spies,
+          spies
         );
       });
 
@@ -486,7 +535,7 @@ describe('plugin-meetings', () => {
           url1,
           resultPromise,
           'Host Key Not Specified Or Matched. The original host can reclaim the host role without entering the host key. However, any other person who claims the host role must enter the host key to get it.',
-          spies,
+          spies
         );
       });
 
@@ -503,7 +552,7 @@ describe('plugin-meetings', () => {
           url1,
           resultPromise,
           'Participant Having Host Role Already. Participant who sends request to reclaim host role has already a host role.',
-          spies,
+          spies
         );
       });
 
@@ -520,7 +569,7 @@ describe('plugin-meetings', () => {
           url1,
           resultPromise,
           genericMessage,
-          spies,
+          spies
         );
       });
 
@@ -530,13 +579,7 @@ describe('plugin-meetings', () => {
 
         const resultPromise = members.assignRoles(memberId, fakeRoles);
 
-        await checkValid(
-          resultPromise,
-          spies,
-          memberId,
-          fakeRoles,
-          url1,
-        );
+        await checkValid(resultPromise, spies, memberId, fakeRoles, url1);
       });
     });
 
@@ -661,19 +704,19 @@ describe('plugin-meetings', () => {
         spies,
         expectedRequestingMemberId,
         expectedLocusUrl,
-        expectedRoles,
+        expectedRoles
       ) => {
         await assert.isFulfilled(resultPromise);
         assert.calledOnceWithExactly(
           spies.generateLowerAllHandsMemberOptions,
           expectedRequestingMemberId,
           expectedLocusUrl,
-          expectedRoles,
+          expectedRoles
         );
         assert.calledOnceWithExactly(spies.lowerAllHandsMember, {
           requestingParticipantId: expectedRequestingMemberId,
           locusUrl: expectedLocusUrl,
-          ...(expectedRoles !== undefined && { roles: expectedRoles })
+          ...(expectedRoles !== undefined && {roles: expectedRoles}),
         });
         assert.strictEqual(resultPromise, spies.lowerAllHandsMember.getCall(0).returnValue);
       };
@@ -714,7 +757,7 @@ describe('plugin-meetings', () => {
       it('should make the correct request when called with valid requestingMemberId and roles', async () => {
         const requestingMemberId = 'test-member-id';
         const roles = ['panelist', 'attendee'];
-        const { members, spies } = setup('test-locus-url');
+        const {members, spies} = setup('test-locus-url');
 
         const resultPromise = members.lowerAllHands(requestingMemberId, roles);
 
@@ -724,7 +767,7 @@ describe('plugin-meetings', () => {
       it('should handle an empty roles array correctly', async () => {
         const requestingMemberId = 'test-member-id';
         const roles = [];
-        const { members, spies } = setup('test-locus-url');
+        const {members, spies} = setup('test-locus-url');
 
         const resultPromise = members.lowerAllHands(requestingMemberId, roles);
 
@@ -977,5 +1020,76 @@ describe('plugin-meetings', () => {
         );
       });
     });
+
+    describe('#moveToLobby', () => {
+      const setup = (locusUrl) => {
+        const members = createMembers({url: locusUrl});
+
+        const spies = {
+          getMoveMemberToLobbyRequestBody: sandbox.spy(
+            MembersUtil,
+            'getMoveMemberToLobbyRequestBody'
+          ),
+          moveToLobbyMember: sandbox.spy(members.membersRequest, 'moveToLobbyMember'),
+        };
+
+        return {members, spies};
+      };
+
+      const checkInvalid = async (resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, ParameterError, expectedMessage);
+        assert.notCalled(spies.getMoveMemberToLobbyRequestBody);
+        assert.notCalled(spies.moveToLobbyMember);
+      };
+
+      const checkValid = async (resultPromise, spies, expectedMemberId, expectedLocusUrl) => {
+        await assert.isFulfilled(resultPromise);
+        assert.calledOnceWithExactly(spies.getMoveMemberToLobbyRequestBody, expectedMemberId);
+        assert.calledOnceWithExactly(
+          spies.moveToLobbyMember,
+          {
+            locusUrl: expectedLocusUrl,
+            memberId: expectedMemberId,
+          },
+          {
+            moveToLobby: {participantIds: [expectedMemberId]},
+          }
+        );
+        assert.strictEqual(resultPromise, spies.moveToLobbyMember.getCall(0).returnValue);
+      };
+
+      it('should not make a request if there is no member id', async () => {
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.moveToLobby();
+
+        await checkInvalid(
+          resultPromise,
+          'The member id must be defined to move the member to lobby.',
+          spies
+        );
+      });
+
+      it('should not make a request if there is no locus url', async () => {
+        const {members, spies} = setup();
+
+        const resultPromise = members.moveToLobby(uuid.v4());
+
+        await checkInvalid(
+          resultPromise,
+          'The associated locus url for this meetings members object must be defined.',
+          spies
+        );
+      });
+
+      it('should make the correct request when called with valid memberId and locusUrl', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.moveToLobby(memberId);
+
+        await checkValid(resultPromise, spies, memberId, url1);
+      });
+    });
   });
 });