@webex/plugin-meetings 3.0.0-beta.18 → 3.0.0-beta.180

package/test/unit/spec/reconnection-manager/index.js

@@ -3,7 +3,6 @@ import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
-import Metrics from '@webex/plugin-meetings/src/metrics';
 
 const {assert} = chai;
 
@@ -16,7 +15,6 @@ describe('plugin-meetings', () => {
     let fakeMeeting;
 
     beforeEach(() => {
-      Metrics.postEvent = sinon.stub();
       fakeMediaConnection = {
         initiateOffer: sinon.stub().resolves({}),
         reconnect: sinon.stub().resolves({}),
@@ -43,8 +41,8 @@ describe('plugin-meetings', () => {
           webrtcMediaConnection: fakeMediaConnection,
         },
         mediaRequestManagers: {
-          audio: {commit: sinon.stub()},
-          video: {commit: sinon.stub()},
+          audio: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+          video: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
         },
         roap: {
           doTurnDiscovery: sinon.stub().resolves({
@@ -64,6 +62,11 @@ describe('plugin-meetings', () => {
             getMeetingByType: sinon.stub().returns(true),
             syncMeetings: sinon.stub().resolves({}),
           },
+          internal: {
+            newMetrics: {
+              submitClientEvent: sinon.stub()
+            }
+          }
         },
       };
     });
@@ -82,27 +85,77 @@ describe('plugin-meetings', () => {
           credential: 'fake_turn_password',
         },
       ]);
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: rm.meeting.id,
+        },
+      });
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.recovered',
+        payload: {
+          recoveredBy: 'new',
+        },
+        options: {
+          meetingId: rm.meeting.id,
+        },
+      });
     });
 
-    it('does not re-request media for non-multistream meetings', async () => {
+    it('does not clear previous requests and re-request media for non-multistream meetings', async () => {
       fakeMeeting.isMultistream = false;
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
+      assert.notCalled(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
+      assert.notCalled(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
       assert.notCalled(fakeMeeting.mediaRequestManagers.audio.commit);
       assert.notCalled(fakeMeeting.mediaRequestManagers.video.commit);
     });
 
-    it('does re-request media for multistream meetings', async () => {
+    it('does clear previous requests and re-request media for multistream meetings', async () => {
       fakeMeeting.isMultistream = true;
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
       assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.commit);
       assert.calledOnce(fakeMeeting.mediaRequestManagers.video.commit);
     });
+
+
+    it('sends the correct client event when reconnection fails', async () => {
+      sinon.stub(ReconnectionManager.prototype, 'executeReconnection').rejects();
+      fakeMeeting.isMultistream = true;
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      try {
+        await rm.reconnect();
+      } catch (err) {
+        assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.aborted',
+          payload: {
+            errors: [
+              {
+                category: 'expected',
+                errorCode: 2008,
+                fatal: true,
+                name: 'media-engine',
+                shownToUser: false,
+              },
+            ],
+          },
+          options: {
+            meetingId: rm.meeting.id,
+          },
+        });
+      }
+    });
   });
 
   /**

package/test/unit/spec/recording-controller/index.js

@@ -1,231 +1,307 @@
 import RecordingController from '@webex/plugin-meetings/src/recording-controller';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
-import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
+import {HTTP_VERBS, SELF_POLICY} from '@webex/plugin-meetings/src/constants';
+
 
 describe('plugin-meetings', () => {
-    describe('recording-controller tests', () => {
-        describe('index', () => {
-            let request;
-
-            describe('class tests', () => {
-                it('can set and extract new values later on', () => {
-                    const controller = new RecordingController({});
-                    assert.isUndefined(controller.getServiceUrl());
-                    assert.isUndefined(controller.getSessionId());
-                    assert.isUndefined(controller.getLocusUrl());
-                    assert.isUndefined(controller.getLocusId());
-                    controller.set({
-                      serviceUrl: 'test',
-                      sessionId: 'testId',
-                      locusUrl: 'test/id',
-                      displayHints: [],
-                    })
-                    assert(controller.getServiceUrl(), 'test');
-                    assert(controller.getSessionId(), 'testId');
-                    assert(controller.getLocusUrl(), 'test/id');
-                    assert(controller.getLocusId(), 'id');
-                });
+  describe('recording-controller tests', () => {
+    describe('index', () => {
+      let request;
+
+      describe('class tests', () => {
+        it('can set and extract new values later on', () => {
+          const controller = new RecordingController({});
+          assert.isUndefined(controller.getServiceUrl());
+          assert.isUndefined(controller.getSessionId());
+          assert.isUndefined(controller.getLocusUrl());
+          assert.isUndefined(controller.getLocusId());
+          controller.set({
+            serviceUrl: 'test',
+            sessionId: 'testId',
+            locusUrl: 'test/id',
+            displayHints: [],
+          });
+          assert(controller.getServiceUrl(), 'test');
+          assert(controller.getSessionId(), 'testId');
+          assert(controller.getLocusUrl(), 'test/id');
+          assert(controller.getLocusId(), 'id');
+        });
+      });
+
+      describe('legacy locus style recording', () => {
+        const locusUrl = 'locusUrl';
+        let controller;
+
+        beforeEach(() => {
+          request = {
+            request: sinon.stub().returns(Promise.resolve()),
+          };
+
+          controller = new RecordingController(request);
+
+          controller.set({
+            locusUrl,
+            displayHints: [],
+          });
+        });
+
+        describe('startRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.startRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_START']);
+            controller.setUserPolicy({[SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false});
+            const result = controller.startRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can start recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: true, paused: false}},
+              method: HTTP_VERBS.PATCH,
             });
 
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('stopRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.stopRecording();
 
-            describe('legacy locus style recording', () => {
-                const locusUrl = 'locusUrl';
-                let controller;
-            
-                beforeEach(() => {
-                  request = {
-                    request: sinon.stub().returns(Promise.resolve()),
-                  };
-
-                  controller = new RecordingController(request);
-
-                  controller.set({
-                    locusUrl,
-                    displayHints: [],
-                  })
-                  
-                });
-            
-                describe('startRecording', () => {
-                  it('rejects when correct display hint is not present', () => {
-                    const result = controller.startRecording();
-            
-                    assert.notCalled(request.request);
-            
-                    assert.isRejected(result);
-                  });
-    
-                  it('can start recording when the correct display hint is present', () => {
-                    controller.setDisplayHints(['RECORDING_CONTROL_START']);
-            
-                    const result = controller.startRecording();
-            
-                    assert.calledWith(request.request, {uri: `${locusUrl}/controls`, body: {record: {recording: true, paused: false}}, method: HTTP_VERBS.PATCH});
-            
-                    assert.deepEqual(result, request.request.firstCall.returnValue);
-                  });
-                });
-
-                describe('stopRecording', () => {
-                    it('rejects when correct display hint is not present', () => {
-                      const result = controller.stopRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can stop recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
-              
-                      const result = controller.stopRecording();
-              
-                      assert.calledWith(request.request, {uri: `${locusUrl}/controls`, body: {record: {recording: false, paused: false}}, method: HTTP_VERBS.PATCH});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
-
-                  describe('pauseRecording', () => {
-                    it('rejects when correct display hint is not present', () => {
-                      const result = controller.pauseRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can pause recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
-
-                      const result = controller.pauseRecording();
-              
-                      assert.calledWith(request.request, {uri: `${locusUrl}/controls`, body: {record: {recording: true, paused: true}}, method: HTTP_VERBS.PATCH});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
-
-                  describe('resumeRecording', () => {
-                    it('rejects when correct display hint is not present', () => {
-                      const result = controller.pauseRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can resume recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
-              
-                      const result = controller.resumeRecording();
-              
-                      assert.calledWith(request.request, {uri: `${locusUrl}/controls`, body: {record: {recording: true, paused: false}}, method: HTTP_VERBS.PATCH});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
+            controller.setUserPolicy({[SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false})
+            const result = controller.stopRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can stop recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: false, paused: false}},
+              method: HTTP_VERBS.PATCH,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('pauseRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
+            controller.setUserPolicy({
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            });
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can pause recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: true, paused: true}},
+              method: HTTP_VERBS.PATCH,
             });
 
-            describe('recording streaming service style tests', () => {
-                let controller;
-            
-                beforeEach(() => {
-                  request = {
-                    request: sinon.stub().returns(Promise.resolve()),
-                  };
-
-                  controller = new RecordingController(request);
-
-                  controller.set({
-                    serviceUrl: 'test',
-                    sessionId: 'testId',
-                    locusUrl: 'test/id',
-                    displayHints: [],
-                  })
-                });
-
-                describe('startRecording', () => {
-                    it('rejects when correct display hint is not present', () => {  
-                      const result = controller.startRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can start recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_START']);
-              
-                      const result = controller.startRecording();
-              
-                      assert.calledWith(request.request, {uri: `test/loci/id/recording`, body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}}, method: HTTP_VERBS.PUT});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
-
-                  describe('stopRecording', () => {
-                    it('rejects when correct display hint is not present', () => {
-                      const result = controller.pauseRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can start recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
-              
-                      const result = controller.stopRecording();
-              
-                      assert.calledWith(request.request, {uri: `test/loci/id/recording`, body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}}, method: HTTP_VERBS.PUT});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
-
-                  describe('pauseRecording', () => {
-                    it('rejects when correct display hint is not present', () => {  
-                      const result = controller.pauseRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can pause recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
-              
-                      const result = controller.pauseRecording();
-              
-                      assert.calledWith(request.request, {uri: `test/loci/id/recording`, body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}}, method: HTTP_VERBS.PUT});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
-
-                  describe('resumeRecording', () => {
-                    it('rejects when correct display hint is not present', () => {
-                      const result = controller.resumeRecording();
-              
-                      assert.notCalled(request.request);
-              
-                      assert.isRejected(result);
-                    });
-      
-                    it('can resume recording when the correct display hint is present', () => {
-                      controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
-              
-                      const result = controller.resumeRecording();
-              
-                      assert.calledWith(request.request, {uri: `test/loci/id/recording`, body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}}, method: HTTP_VERBS.PUT});
-              
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
-                    });
-                  });
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('resumeRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
+            controller.setUserPolicy({
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
             });
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+
+          it('can resume recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: true, paused: false}},
+              method: HTTP_VERBS.PATCH,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+      });
+
+      describe('recording streaming service style tests', () => {
+        let controller;
+
+        beforeEach(() => {
+          request = {
+            request: sinon.stub().returns(Promise.resolve()),
+          };
+
+          controller = new RecordingController(request);
+
+          controller.set({
+            serviceUrl: 'test',
+            sessionId: 'testId',
+            locusUrl: 'test/id',
+            displayHints: [],
+          });
+        });
+
+        describe('startRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.startRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can start recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('stopRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can start recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('pauseRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can pause recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('resumeRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.resumeRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can resume recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
           });
+        });
+      });
     });
-});
+  });
+});