@webex/plugin-meetings 3.0.0-beta.174 → 3.0.0-beta.176

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

@@ -12,6 +12,7 @@ describe('plugin-meetings', () => {
     beforeEach(() => {
       // @ts-ignore
       webex = new MockWebex({});
+      webex.internal.mercury.on = sinon.stub();
       interpretation = new SimultaneousInterpretation({}, {parent: webex});
       interpretation.locusUrl = 'locusUrl';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
@@ -50,6 +51,14 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#approvalUrlUpdate', () => {
+      it('sets the approval url', () => {
+        interpretation.approvalUrlUpdate('newUrl');
+
+        assert.equal(interpretation.approvalUrl, 'newUrl');
+      });
+    });
+
     describe('#updateCanManageInterpreters', () => {
       it('update canManageInterpreters', () => {
         interpretation.updateCanManageInterpreters(true);
@@ -62,6 +71,18 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#updateHostSIEnabled', () => {
+      it('update hostSI feature is on or off', () => {
+        interpretation.updateHostSIEnabled(true);
+
+        assert.equal(interpretation.hostSIEnabled, true);
+
+        interpretation.updateHostSIEnabled(false);
+
+        assert.equal(interpretation.hostSIEnabled, false);
+      });
+    });
+
     describe('#updateInterpretation', () => {
       const checkSILanguage = (siLanguage, expectResult) => {
         return siLanguage?.languageCode === expectResult.languageCode && siLanguage?.languageName === expectResult.languageName
@@ -69,15 +90,6 @@ describe('plugin-meetings', () => {
       it('update interpretation correctly', () => {
         interpretation.updateInterpretation({siLanguages: [{languageName: 'en', languageCode: 1}]});
         checkSILanguage(interpretation.siLanguages.en, {languageName: 'en', languageCode: 1});
-        assert.equal(interpretation.siEnabled, true);
-      });
-
-      it('check siEnable as false if input param interpretation is null/undefined', () => {
-        interpretation.updateInterpretation(null);
-        assert.equal(interpretation.siEnabled, false);
-
-        interpretation.updateInterpretation(undefined);
-        assert.equal(interpretation.siEnabled, false);
       });
     });
 
@@ -325,5 +337,234 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#listenToHandoffRequests', () => {
+      it('triggers handoff update event when the approval is related with self', () => {
+        const call = webex.internal.mercury.on.getCall(0);
+        const callback = call.args[1];
+
+        assert.equal(call.args[0], 'event:locus.approval_request');
+        interpretation.set('selfParticipantId', 'p123');
+
+        let called = false;
+        const triggerSpy = sinon.spy(interpretation, 'trigger');
+
+        interpretation.listenTo(interpretation, 'HANDOFF_REQUESTS_ARRIVED', () => {
+          called = true;
+        });
+
+        callback({
+          data: {
+            approval: {
+              actionType: 'OFFERED',
+              resourceType: 'SiHandover',
+              receivers: [{
+                participantId: 'p123',
+              }],
+              initiator: {participantId: 'p123'},
+              url: 'testUrl',
+            },
+          }
+        });
+
+        assert.isTrue(called);
+        assert.calledWithExactly(triggerSpy, 'HANDOFF_REQUESTS_ARRIVED', {
+          actionType: 'OFFERED',
+          isReceiver: true,
+          isSender: true,
+          senderId: 'p123',
+          receiverId: 'p123',
+          url: 'testUrl',
+        });
+      });
+
+      it('not triggers handoff update event when the approval is not related with self', () => {
+        const call = webex.internal.mercury.on.getCall(0);
+        const callback = call.args[1];
+
+        interpretation.set('selfParticipantId', 'p123');
+
+        let called = false;
+
+        interpretation.listenTo(interpretation, 'HANDOFF_REQUESTS_ARRIVED', () => {
+          called = true;
+        });
+
+        callback({
+          data: {
+            approval: {
+              actionType: 'OFFERED',
+              resourceType: 'SiHandover',
+              receivers: [{
+                participantId: 'p444',
+              }],
+              initiator: {participantId: 'p444'},
+              url: 'testUrl',
+            },
+          }
+        });
+
+        assert.isFalse(called);
+      });
+    });
+
+    describe('#handoffInterpreter', () => {
+      it('makes the request as expected', async () => {
+        interpretation.approvalUrlUpdate('approvalUrl');
+        await interpretation.handoffInterpreter('participant2');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'approvalUrl',
+          body: {
+            actionType: 'OFFERED',
+            resourceType: 'SiHandover',
+            receivers: [
+              {
+                participantId: 'participant2',
+              },
+            ],
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+        interpretation.approvalUrlUpdate('approvalUrl');
+
+        await assert.isRejected(interpretation.handoffInterpreter('p2'), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#handoffInterpreter failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no target participant id', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.handoffInterpreter().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing target participant id');
+        });
+      });
+
+      it('rejects error when no approval url', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.handoffInterpreter('p2').catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing approval url');
+        });
+      });
+    });
+
+    describe('#requestHandoff', () => {
+      it('makes the request as expected', async () => {
+        interpretation.approvalUrlUpdate('approvalUrl');
+        await interpretation.requestHandoff();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'approvalUrl',
+          body: {
+            actionType: 'REQUESTED',
+            resourceType: 'SiHandover',
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+        interpretation.approvalUrlUpdate('approvalUrl');
+
+        await assert.isRejected(interpretation.requestHandoff(), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#requestHandoff failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no approval url', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.requestHandoff().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing approval url');
+        });
+      });
+    });
+
+    describe('#acceptRequest', () => {
+      it('makes the request as expected', async () => {
+        await interpretation.acceptRequest('testUrl');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'testUrl',
+          body: {
+            actionType: 'ACCEPTED',
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+
+        await assert.isRejected(interpretation.acceptRequest('testUrl'), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#acceptRequest failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no url passed', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.acceptRequest().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing the url to accept');
+        });
+      });
+    });
+
+    describe('#declineRequest', () => {
+      it('makes the request as expected', async () => {
+        await interpretation.declineRequest('testUrl');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'testUrl',
+          body: {
+            actionType: 'DECLINED',
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+
+        await assert.isRejected(interpretation.declineRequest('testUrl'), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#declineRequest failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no url passed', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.declineRequest().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing the url to decline');
+        });
+      });
+    });
   });
 });

package/test/unit/spec/interpretation/siLanguage.ts

@@ -2,6 +2,7 @@ import {assert} from '@webex/test-helper-chai';
 import SILanguage from '@webex/plugin-meetings/src/interpretation/siLanguage';
 import SimultaneousInterpretation from '@webex/plugin-meetings/src/interpretation';
 import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
 
 describe('plugin-meetings', () => {
   describe('SILanguage', () => {
@@ -11,6 +12,7 @@ describe('plugin-meetings', () => {
     beforeEach(() => {
       // @ts-ignore
       webex = new MockWebex({});
+      webex.internal.mercury.on = sinon.stub();
       interpretation = new SimultaneousInterpretation({}, {parent: webex});
       siLanguage = new SILanguage({}, {parent: interpretation});
     });

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

@@ -1335,7 +1335,7 @@ describe('plugin-meetings', () => {
               icePhase: 'JOIN_MEETING_FINAL',
               errors: [{}],
             },
-            options: {                   
+            options: {
               meetingId: meeting.id,
             },
           });
@@ -3831,7 +3831,7 @@ describe('plugin-meetings', () => {
             assert.equal(meeting.mediaProperties.shareVideoTrack, track);
             assert.equal(meeting.mediaProperties.mediaDirection.sendShare, true);
           };
-          
+
           const checkScreenShareAudioPublished = (track) => {
             assert.calledOnce(meeting.requestScreenShareFloor);
 
@@ -3849,27 +3849,27 @@ describe('plugin-meetings', () => {
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
             checkScreenShareVideoPublished(videoShareTrack);
           });
-          
+
           it('requests screen share floor and publishes the screen share audio track', async () => {
             await meeting.publishTracks({screenShare: {audio: audioShareTrack}});
-            
+
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
             checkScreenShareAudioPublished(audioShareTrack);
           });
-          
+
           it('does not request screen share floor when publishing video share track if already sharing audio', async () => {
             await meeting.publishTracks({screenShare: {audio: audioShareTrack}});
             assert.calledOnce(meeting.requestScreenShareFloor);
-            
+
             meeting.requestScreenShareFloor.reset();
             await meeting.publishTracks({screenShare: {video: videoShareTrack}});
             assert.notCalled(meeting.requestScreenShareFloor);
           })
-          
+
           it('does not request screen share floor when publishing audio share track if already sharing video', async () => {
             await meeting.publishTracks({screenShare: {video: videoShareTrack}});
             assert.calledOnce(meeting.requestScreenShareFloor);
-            
+
             meeting.requestScreenShareFloor.reset();
             await meeting.publishTracks({screenShare: {audio: audioShareTrack}});
             assert.notCalled(meeting.requestScreenShareFloor);
@@ -4007,26 +4007,26 @@ describe('plugin-meetings', () => {
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
             checkScreenShareVideoUnpublished();
           });
-          
+
           it('un-publishes the screen share audio track correctly', async () => {
             await meeting.unpublishTracks([audioShareTrack]);
-            
+
             assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
             checkScreenShareAudioUnpublished();
           });
-          
+
           it('releases share floor and sets send direction to false when both screen share tracks are undefined', async () => {
             await meeting.unpublishTracks([videoShareTrack, audioShareTrack]);
-            
+
             assert.calledOnce(meeting.releaseScreenShareFloor);
             assert.equal(meeting.mediaProperties.mediaDirection.sendShare, false);
           });
-          
+
           it('does not release share floor when audio is released and video still exists', async () => {
             await meeting.unpublishTracks([audioShareTrack]);
             assert.notCalled(meeting.releaseScreenShareFloor);
           });
-          
+
           it('does not release share floor when video is released and audio still exists', async () => {
             await meeting.unpublishTracks([videoShareTrack]);
             assert.notCalled(meeting.releaseScreenShareFloor);
@@ -4287,7 +4287,7 @@ describe('plugin-meetings', () => {
                 icePhase: 'IN_MEETING',
                 errors: [{}],
               },
-              options: {                   
+              options: {
                 meetingId: meeting.id,
               },
             });
@@ -5108,6 +5108,9 @@ describe('plugin-meetings', () => {
           meeting.annotation = {
             approvalUrlUpdate: sinon.stub().returns(undefined),
           };
+          meeting.simultaneousInterpretation = {
+            approvalUrlUpdate: sinon.stub().returns(undefined),
+          };
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -5123,6 +5126,10 @@ describe('plugin-meetings', () => {
             meeting.annotation.approvalUrlUpdate,
             newLocusServices.services.approval.url,
           );
+          assert.calledWith(
+            meeting.simultaneousInterpretation.approvalUrlUpdate,
+            newLocusServices.services.approval.url,
+          );
           assert.calledOnce(meeting.recordingController.setSessionId);
           done();
         });
@@ -5226,6 +5233,20 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE
           );
         });
+
+        it('listens to the handoff request event from interpretation and triggers the update event', () => {
+          TriggerProxy.trigger.reset();
+          const payload = {};
+          meeting.simultaneousInterpretation.trigger('HANDOFF_REQUESTS_ARRIVED', payload);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpInterpretationListener'},
+            EVENT_TRIGGERS.MEETING_INTERPRETATION_HANDOFF_REQUESTS_ARRIVED,
+            payload
+          );
+        });
       });
     });
     describe('Private Detailed API and Helpers', () => {
@@ -5508,6 +5529,26 @@ describe('plugin-meetings', () => {
 
           checkParseMeetingInfo(expectedInfoToParse);
         });
+        it('should set hostSIEnabled correctly depend on the toggle statue in site setting', () => {
+          const updateHostSIEnabledSpy = sinon.spy(meeting.simultaneousInterpretation, 'updateHostSIEnabled');
+          const mockToggleOnData = {
+            body: {
+              meetingSiteSetting: {
+                enableHostInterpreterControlSI: true,
+              }
+            }
+          };
+          meeting.parseMeetingInfo(mockToggleOnData);
+          assert.calledWith(updateHostSIEnabledSpy, true);
+
+          const mockToggleOffData = {
+            body: {
+              meetingSiteSetting: {}
+            }
+          };
+          meeting.parseMeetingInfo(mockToggleOffData);
+          assert.calledWith(updateHostSIEnabledSpy, false);
+        });
       });
 
       describe('#setCorrelationId', () => {
@@ -6178,7 +6219,7 @@ describe('plugin-meetings', () => {
                     eventTrigger.share.push({
                       eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
                       functionName: 'remoteShare',
-                      eventPayload: {memberId: beneficiaryId, url, shareInstanceId},
+                      eventPayload: {memberId: beneficiaryId, url, shareInstanceId , annotationInfo:undefined},
                     });
                   }
                 }