@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

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

@@ -1,7 +1,7 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
-import createMuteState from '@webex/plugin-meetings/src/meeting/muteState';
+import {createMuteState} from '@webex/plugin-meetings/src/meeting/muteState';
 import Media from '@webex/plugin-meetings/src/media/index';
 import PermissionError from '@webex/plugin-meetings/src/common/errors/permission';
 import {AUDIO, VIDEO} from '@webex/plugin-meetings/src/constants';
@@ -19,18 +19,21 @@ describe('plugin-meetings', () => {
   beforeEach(() => {
     meeting = {
       mediaProperties: {
-        audioTrack: 'fake audio track',
-        videoTrack: 'fake video track'
+        audioTrack: {id: 'fake audio track', setMuted: sinon.stub()},
+        videoTrack: {id: 'fake video track', setMuted: sinon.stub()},
       },
       remoteMuted: false,
       unmuteAllowed: true,
+      remoteVideoMuted: false,
+      unmuteVideoAllowed: true,
+
       locusInfo: {
-        onFullLocus: sinon.stub()
+        onFullLocus: sinon.stub(),
       },
       members: {
         selfId: 'fake self id',
-        muteMember: sinon.stub().resolves()
-      }
+        muteMember: sinon.stub().resolves(),
+      },
     };
     audio = createMuteState(AUDIO, meeting, {sendAudio: true});
     video = createMuteState(VIDEO, meeting, {sendVideo: true});
@@ -38,7 +41,6 @@ describe('plugin-meetings', () => {
     originalRemoteUpdateAudioVideo = MeetingUtil.remoteUpdateAudioVideo;
 
     MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves(fakeLocus);
-    Media.setLocalTrack = sinon.stub();
   });
 
   afterEach(() => {
@@ -76,15 +78,16 @@ describe('plugin-meetings', () => {
     });
 
     it('initialises correctly for video', async () => {
-      // setup fields related to audio remote state
-      meeting.remoteMuted = true;
-      meeting.unmuteAllowed = false;
-      // create a new video MuteState intance
+      // setup fields related to video remote state
+      meeting.remoteVideoMuted = false;
+      meeting.unmuteVideoAllowed = false;
+
+      // create a new video MuteState instance
       video = createMuteState(VIDEO, meeting, {sendVideo: true});
 
       assert.isFalse(video.isMuted());
       assert.isFalse(video.state.server.remoteMute);
-      assert.isTrue(video.state.server.unmuteAllowed);
+      assert.isFalse(video.state.server.unmuteAllowed);
     });
 
     it('takes remote mute into account when reporting current state', async () => {
@@ -110,8 +113,8 @@ describe('plugin-meetings', () => {
       audio.handleServerLocalUnmuteRequired(meeting);
       await testUtils.flushPromises();
 
-      // check that local track was enabled
-      assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+      // check that local track was unmuted
+      assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
 
       // and local unmute was sent to server
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
@@ -128,11 +131,14 @@ describe('plugin-meetings', () => {
       // first we need to mute and make that request last forever
       let serverResponseResolve;
 
-      MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(new Promise((resolve) => {
-        serverResponseResolve = resolve;
-      }));
+      MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+        new Promise((resolve) => {
+          serverResponseResolve = resolve;
+        })
+      );
 
-      audio.handleClientRequest(meeting, true)
+      audio
+        .handleClientRequest(meeting, true)
         .then(() => {
           clientPromiseResolved = true;
         })
@@ -158,48 +164,92 @@ describe('plugin-meetings', () => {
       assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
       assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, false, undefined, meeting);
 
-      // and local track should be enabled
-      assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+      // and local track should be unmuted
+      assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
 
       assert.isFalse(audio.isMuted());
       assert.isFalse(audio.isSelf());
     });
 
+    it('does local video unmute if localVideoUnmuteRequired is received', async () => {
+      // first we need to mute
+      await video.handleClientRequest(meeting, true);
+
+      assert.isTrue(video.isMuted());
+      assert.isTrue(video.isSelf());
+
+      MeetingUtil.remoteUpdateAudioVideo.resetHistory();
+
+      // now simulate server requiring us to locally unmute
+      video.handleServerLocalUnmuteRequired(meeting);
+      await testUtils.flushPromises();
+
+      // check that local track was unmuted
+      assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
+
+      // and local unmute was sent to server
+      assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
+      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, false, meeting);
+
+      assert.isFalse(video.isMuted());
+      assert.isFalse(video.isSelf());
+    });
+
+    describe('#isLocallyMuted()', () => {
+      it('does not consider remote mute status for audio', async () => {
+        // simulate being already remote muted
+        meeting.remoteMuted = true;
+        // create a new MuteState intance
+        audio = createMuteState(AUDIO, meeting, {sendAudio: true});
+
+        assert.isFalse(audio.isLocallyMuted());
+      });
+
+      it('does not consider remote mute status for video', async () => {
+        // simulate being already remote muted
+        meeting.remoteVideoMuted = true;
+        // create a new MuteState intance
+        video = createMuteState(VIDEO, meeting, {sendVideo: true});
+
+        assert.isFalse(video.isLocallyMuted());
+      });
+    });
+
     describe('#handleClientRequest', () => {
       it('disables/enables the local audio track when audio is muted/unmuted', async () => {
         // mute
         audio.handleClientRequest(meeting, true);
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, true);
 
-        // even when calling mute when it's already muted should still call setLocalTrack
+        // even when calling mute when it's already muted should still call setMuted
         audio.handleClientRequest(meeting, true);
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, true);
 
         // unmute
         audio.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
 
-        // even when calling unmute when it's already unmuted should still call setLocalTrack
+        // even when calling unmute when it's already unmuted should still call setMuted
         audio.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.audioTrack);
+        assert.calledWith(meeting.mediaProperties.audioTrack.setMuted, false);
       });
 
       it('disables/enables the local video track when video is muted/unmuted', async () => {
         // mute
         video.handleClientRequest(meeting, true);
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
 
-        // even when calling mute when it's already muted should still call setLocalTrack
+        // even when calling mute when it's already muted should still call setMuted
         video.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
 
         // unmute
         video.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
 
-        // even when calling unmute when it's already unmuted should still call setLocalTrack
+        // even when calling unmute when it's already unmuted should still call setMuted
         video.handleClientRequest(meeting, false);
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
       });
 
       it('returns correct value in isMuted()/isSelf() methods after client mute/unmute requests', async () => {
@@ -225,25 +275,55 @@ describe('plugin-meetings', () => {
 
         // check that remote unmute was sent to server
         assert.calledOnce(meeting.members.muteMember);
-        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false);
+        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, true);
 
         assert.isFalse(audio.isMuted());
         assert.isFalse(audio.isSelf());
       });
 
+      it('does video remote unmute when unmuting and remote mute is on', async () => {
+        // simulate remote mute
+        video.handleServerRemoteMuteUpdate(true, true);
+
+        // unmute
+        await video.handleClientRequest(meeting, false);
+
+        // check that remote unmute was sent to server
+        assert.calledOnce(meeting.members.muteMember);
+        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, false);
+
+        assert.isFalse(video.isMuted());
+        assert.isFalse(video.isSelf());
+      });
+
+      it('does not video remote unmute when unmuting and remote mute is off', async () => {
+        // simulate remote mute
+        video.handleServerRemoteMuteUpdate(false, true);
+
+        // unmute
+        await video.handleClientRequest(meeting, false);
+
+        // check that remote unmute was sent to server
+        assert.notCalled(meeting.members.muteMember);
+
+        assert.isFalse(video.isMuted());
+        assert.isFalse(video.isSelf());
+      });
+
       it('resolves client request promise once the server is updated', async () => {
         let clientPromiseResolved = false;
 
         let serverResponseResolve;
 
-        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(new Promise((resolve) => {
-          serverResponseResolve = resolve;
-        }));
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+          new Promise((resolve) => {
+            serverResponseResolve = resolve;
+          })
+        );
 
-        audio.handleClientRequest(meeting, true)
-          .then(() => {
-            clientPromiseResolved = true;
-          });
+        audio.handleClientRequest(meeting, true).then(() => {
+          clientPromiseResolved = true;
+        });
 
         // do a small delay to make sure that the client promise doesn't resolve in that time
         await testUtils.waitUntil(200);
@@ -257,9 +337,11 @@ describe('plugin-meetings', () => {
       });
 
       it('rejects client request promise if server request for local mute fails', async () => {
-        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(new Promise((resolve, reject) => {
-          reject();
-        }));
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+          new Promise((resolve, reject) => {
+            reject();
+          })
+        );
 
         assert.isRejected(audio.handleClientRequest(meeting, true));
       });
@@ -282,9 +364,11 @@ describe('plugin-meetings', () => {
       it('does not send a server request if client state matches the server', async () => {
         let serverResponseResolve;
 
-        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(new Promise((resolve) => {
-          serverResponseResolve = resolve;
-        }));
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+          new Promise((resolve) => {
+            serverResponseResolve = resolve;
+          })
+        );
 
         // simulate many client requests, with the last one matching the initial one
         audio.handleClientRequest(meeting, true);
@@ -309,22 +393,22 @@ describe('plugin-meetings', () => {
       it('queues up server requests when multiple client requests are received', async () => {
         let serverResponseResolve;
 
-        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(new Promise((resolve) => {
-          serverResponseResolve = resolve;
-        }));
+        MeetingUtil.remoteUpdateAudioVideo = sinon.stub().returns(
+          new Promise((resolve) => {
+            serverResponseResolve = resolve;
+          })
+        );
 
         let firstClientPromiseResolved = false;
         let secondClientPromiseResolved = false;
 
         // 2 client requests, one after another without waiting for first one to resolve
-        audio.handleClientRequest(meeting, true)
-          .then(() => {
-            firstClientPromiseResolved = true;
-          });
-        audio.handleClientRequest(meeting, false)
-          .then(() => {
-            secondClientPromiseResolved = true;
-          });
+        audio.handleClientRequest(meeting, true).then(() => {
+          firstClientPromiseResolved = true;
+        });
+        audio.handleClientRequest(meeting, false).then(() => {
+          secondClientPromiseResolved = true;
+        });
 
         await testUtils.flushPromises();
 
@@ -351,7 +435,8 @@ describe('plugin-meetings', () => {
       it('rejects client request to unmute if hard mute is used', (done) => {
         audio.handleServerRemoteMuteUpdate(true, false);
 
-        audio.handleClientRequest(meeting, false)
+        audio
+          .handleClientRequest(meeting, false)
           .then(() => {
             done(new Error('expected handleClientRequest to fail, but it did not!'));
           })
@@ -369,11 +454,11 @@ describe('plugin-meetings', () => {
         assert.isTrue(video.isSelf());
 
         // check local mute is done, but not remote one
-        assert.calledWith(Media.setLocalTrack, false, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, true);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, true, meeting);
         assert.notCalled(meeting.members.muteMember);
 
-        Media.setLocalTrack.resetHistory();
+        meeting.mediaProperties.videoTrack.setMuted.resetHistory();
         MeetingUtil.remoteUpdateAudioVideo.resetHistory();
         meeting.members.muteMember.resetHistory();
 
@@ -383,7 +468,7 @@ describe('plugin-meetings', () => {
         assert.isFalse(video.isMuted());
         assert.isFalse(video.isSelf());
 
-        assert.calledWith(Media.setLocalTrack, true, meeting.mediaProperties.videoTrack);
+        assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
         assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, false, meeting);
         assert.notCalled(meeting.members.muteMember);
       });

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

@@ -1,7 +1,6 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
-
 import Meetings from '@webex/plugin-meetings';
 import MeetingRequest from '@webex/plugin-meetings/src/meeting/request';
 
@@ -11,26 +10,30 @@ describe('plugin-meetings', () => {
   beforeEach(() => {
     const webex = new MockWebex({
       children: {
-        meetings: Meetings
-      }
+        meetings: Meetings,
+      },
     });
 
     webex.meetings.clientRegion = {
       countryCode: 'US',
-      regionCode: 'WEST-COAST'
+      regionCode: 'WEST-COAST',
     };
 
     webex.internal = {
       services: {
         get: sinon.mock().returns('locusUrl'),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({}))
-      }
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
     };
 
-    meetingsRequest = new MeetingRequest({}, {
-      parent: webex
-    });
+    webex.boundedStorage.get = sinon.mock().returns(Promise.resolve(JSON.stringify({anycastEntryPoint: "aws-eu-west-1"})))
 
+    meetingsRequest = new MeetingRequest(
+      {},
+      {
+        parent: webex,
+      }
+    );
 
     meetingsRequest.request = sinon.mock().returns(Promise.resolve({}));
   });
@@ -45,7 +48,7 @@ describe('plugin-meetings', () => {
         await meetingsRequest.sendDTMF({
           locusUrl,
           deviceUrl,
-          tones
+          tones,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -67,7 +70,7 @@ describe('plugin-meetings', () => {
           deviceUrl,
           layoutType,
           main: {width: 640, height: 480},
-          content: {width: 1280, height: 720}
+          content: {width: 1280, height: 720},
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -75,43 +78,53 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.uri, `${locusUrl}/controls`);
         assert.equal(requestParams.body.layout.type, layoutType);
         assert.equal(requestParams.body.layout.deviceUrl, deviceUrl);
-        assert.deepEqual(requestParams.body.layout.layoutParams, {renderInfo: {main: {width: 640, height: 480}, content: {width: 1280, height: 720}}});
+        assert.deepEqual(requestParams.body.layout.layoutParams, {
+          renderInfo: {main: {width: 640, height: 480}, content: {width: 1280, height: 720}},
+        });
       });
 
       it('throws if width is missing for main', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          main: {height: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            main: {height: 100},
+          })
+        );
       });
 
       it('throws if height is missing for main', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          main: {width: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            main: {width: 100},
+          })
+        );
       });
 
       it('throws if width is missing for content', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          content: {height: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            content: {height: 100},
+          })
+        );
       });
 
       it('throws if height is missing for content', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          content: {width: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            content: {width: 100},
+          })
+        );
       });
     });
 
@@ -128,8 +141,7 @@ describe('plugin-meetings', () => {
           deviceUrl,
           correlationId,
           roapMessage,
-          permissionToken
-
+          permissionToken,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -151,7 +163,7 @@ describe('plugin-meetings', () => {
           deviceUrl,
           correlationId,
           roapMessage,
-          meetingNumber
+          meetingNumber,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -172,7 +184,7 @@ describe('plugin-meetings', () => {
           correlationId,
           roapMessage,
           meetingNumber,
-          inviteeAddress
+          inviteeAddress,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -180,6 +192,48 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.uri, 'locusUrl/loci/call?alternateRedirect=true');
         assert.equal(requestParams.body.invitee.address, 'sipUrl');
       });
+
+      it('adds deviceCapabilities to request when breakouts are supported', async () => {
+        await meetingsRequest.joinMeeting({
+          breakoutsSupported: true
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.deviceCapabilities, ['BREAKOUTS_SUPPORTED']);
+      });
+
+      it('does not add deviceCapabilities to request when breakouts are not supported', async () => {
+        await meetingsRequest.joinMeeting({});
+
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.deviceCapabilities, undefined);
+
+      });
+
+      it('includes joinCookie correctly', async () => {
+        const locusUrl = 'locusURL';
+        const deviceUrl = 'deviceUrl';
+        const correlationId = 'random-uuid';
+        const roapMessage = 'roap-message';
+        const permissionToken = 'permission-token';
+
+        await meetingsRequest.joinMeeting({
+          locusUrl,
+          deviceUrl,
+          correlationId,
+          roapMessage,
+          permissionToken,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
+        assert.deepEqual(requestParams.body.clientMediaPreferences, {
+          "joinCookie": {anycastEntryPoint: "aws-eu-west-1"},
+          "preferTranscoding": true
+        });
+      });
     });
 
     describe('#pstn', () => {
@@ -193,7 +247,7 @@ describe('plugin-meetings', () => {
           locusUrl,
           clientUrl,
           correlationId,
-          dialInUrl
+          dialInUrl,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -217,7 +271,7 @@ describe('plugin-meetings', () => {
           clientUrl,
           correlationId,
           dialOutUrl,
-          phoneNumber
+          phoneNumber,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -240,7 +294,7 @@ describe('plugin-meetings', () => {
           locusUrl,
           selfId,
           correlationId,
-          phoneUrl
+          phoneUrl,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -278,5 +332,49 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.uri, keepAliveUrl);
       });
     });
+
+    describe('#sendReaction', () => {
+      it('sends request to sendReaction', async () => {
+        const reactionChannelUrl = 'reactionChannelUrl';
+        const participantId = 'participantId';
+        const reaction = {
+          type: 'thumb_down',
+          codepoints: '1F44E',
+          shortcodes: ':thumbsdown:',
+          tone: {type: 'normal_skin_tone', codepoints: '', shortcodes: ''},
+        };
+
+        await meetingsRequest.sendReaction({
+          reactionChannelUrl,
+          reaction,
+          participantId,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, reactionChannelUrl);
+        assert.equal(requestParams.body.sender.participantId, participantId);
+        assert.equal(requestParams.body.reaction, reaction);
+      });
+    });
+
+    describe('#toggleReactions', () => {
+      it('sends request to toggleReactions', async () => {
+        const locusUrl = 'locusUrl';
+        const requestingParticipantId = 'requestingParticipantId';
+
+        await meetingsRequest.toggleReactions({
+          enable: true,
+          locusUrl,
+          requestingParticipantId,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'PUT');
+        assert.equal(requestParams.uri, `${locusUrl}/controls`);
+        assert.equal(requestParams.body.reactions.enabled, true);
+        assert.equal(requestParams.body.requestingParticipantId, requestingParticipantId);
+      });
+    });
   });
 });