@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.31

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

@@ -20,11 +20,11 @@ describe('plugin-meetings', () => {
     const initialConfig = {
       videoPacketLossRatioThreshold: 9,
       rttThreshold: 500,
-      jitterThreshold: 500
+      jitterThreshold: 500,
     };
 
     const configObject = {
-      mediaType: 'video',
+      mediaType: 'video-send',
       remoteRtpResults: {
         id: 'RTCRemoteInboundRtpVideoStream_2411086660',
         timestamp: 1624472676193.79,
@@ -39,20 +39,20 @@ describe('plugin-meetings', () => {
         roundTripTime: 0.648,
         fractionLost: 0,
         totalRoundTripTime: 3.554,
-        roundTripTimeMeasurements: 14
+        roundTripTimeMeasurements: 14,
       },
       statsAnalyzerCurrentStats: {
-        audio: {
+        'audio-send': {
           send: {
-            currentPacketLossRatio: 8
-          }
+            currentPacketLossRatio: 8,
+          },
         },
-        video: {
+        'video-send': {
           send: {
-            currentPacketLossRatio: 10
-          }
-        }
-      }
+            currentPacketLossRatio: 10,
+          },
+        },
+      },
     };
 
     const sandbox = sinon.createSandbox();
@@ -75,13 +75,19 @@ describe('plugin-meetings', () => {
 
     it('should emit a network quality judgement event with the proper payload', async () => {
       await networkQualityMonitor.determineUplinkNetworkQuality(configObject);
-      assert(sandBoxEmitSpy.calledWith(sinon.match({
-        file: 'networkQualityMonitor',
-        function: 'emitNetworkQuality'
-      }), sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY), sinon.match({
-        mediaType: 'video',
-        networkQualityScore: 0
-      })));
+      assert(
+        sandBoxEmitSpy.calledWith(
+          sinon.match({
+            file: 'networkQualityMonitor',
+            function: 'emitNetworkQuality',
+          }),
+          sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY),
+          sinon.match({
+            mediaType: 'video-send',
+            networkQualityScore: 0,
+          })
+        )
+      );
     });
 
     it('should reset to default values after determineUplinkNetworkQuality call stack is complete', async () => {

package/test/unit/spec/personal-meeting-room/personal-meeting-room.js

@@ -5,9 +5,7 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {
-  _PERSONAL_ROOM_
-} from '@webex/plugin-meetings/src/constants';
+import {_PERSONAL_ROOM_} from '@webex/plugin-meetings/src/constants';
 import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
 
 describe('personal-meeting-room', () => {
@@ -16,14 +14,11 @@ describe('personal-meeting-room', () => {
 
   beforeEach(() => {
     meetingInfo = {
-      fetchMeetingInfo: sinon.stub().returns(Promise.resolve(
-        {body: {isPmr: true}}
-      ))
+      fetchMeetingInfo: sinon.stub().returns(Promise.resolve({body: {isPmr: true}})),
     };
     pmr = new PersonalMeetingRoom({meetingInfo}, {parent: {}});
   });
 
-
   describe('#get()', () => {
     it('returns personal meeting room info', async () => {
       await pmr.get();

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

@@ -1,52 +1,84 @@
 import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
 import Reachability from '@webex/plugin-meetings/src/reachability/';
 
 describe('isAnyClusterReachable', () => {
-  before(function () {
-    this.jsdom = require('jsdom-global')('', {url: 'http://localhost'});
-  });
-  after(function () {
-    this.jsdom();
-  });
+  let webex;
 
-  afterEach(() => {
-    window.localStorage.clear()
+  beforeEach(() => {
+    webex = new MockWebex();
   });
 
-  const checkIsClusterReachable = (mockStorage: any, expectedValue: boolean) => {
-
+  const checkIsClusterReachable = async (mockStorage: any, expectedValue: boolean) => {
     if (mockStorage) {
-      window.localStorage.setItem('reachability.result', JSON.stringify(mockStorage))
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
     }
-    const reachability = new Reachability({});
+    const reachability = new Reachability(webex);
 
-    const result = reachability.isAnyClusterReachable();
+    const result = await reachability.isAnyClusterReachable();
 
     assert.equal(result, expectedValue);
+  };
+
+  it('returns true when udp is reachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
+  });
 
-  }
+  it('returns true when tcp is reachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'true'}}}, true);
+  });
 
-  it('returns true when udp is reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true)
+  it('returns true when both tcp and udp are reachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'true'}}}, true);
   });
 
-  it('returns true when tcp is reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'true'}}}, true)
+  it('returns false when both tcp and udp are unreachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'false'}}}, false);
   });
 
-  it('returns true when both tcp and udp are reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'true'}}}, true)
+  it('returns false when reachability result is empty', async () => {
+    await checkIsClusterReachable({x: {}}, false);
   });
 
-  it('returns false when both tcp and udp are unreachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'false'}}}, false)
+  it('returns false when reachability.result item is not there', async () => {
+    await checkIsClusterReachable(undefined, false);
   });
+});
+
+describe('gatherReachability', () => {
+  let webex;
 
-  it('returns false when reachability result is empty', () => {
-    checkIsClusterReachable({x: {}}, false)
+  beforeEach(async () => {
+    webex = new MockWebex();
+
+    await webex.boundedStorage.put(
+      'Reachability',
+      'reachability.result',
+      JSON.stringify({old: 'results'})
+    );
   });
 
-  it('returns false when reachability.result item is not there', () => {
-    checkIsClusterReachable(undefined, false)
+  it('stores the reachability', async () => {
+    const reachability = new Reachability(webex);
+
+    const clusters = {some: 'clusters'};
+    const reachabilityResults = {some: 'results'};
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(clusters);
+    (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults)
+
+    const result = await reachability.gatherReachability();
+
+    assert.equal(result, reachabilityResults);
+
+    const storedResult = await webex.boundedStorage.get('Reachability', 'reachability.result');
+
+    assert.equal(JSON.stringify(result), storedResult);
   });
+
 });

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

@@ -2,8 +2,8 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-
-import ReconnectionManager from '../../../../src/reconnection-manager';
+import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 
 const {assert} = chai;
 
@@ -11,6 +11,100 @@ chai.use(chaiAsPromised);
 sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
+  describe('ReconnectionManager.reconnect', () => {
+    let fakeMediaConnection;
+    let fakeMeeting;
+
+    beforeEach(() => {
+      Metrics.postEvent = sinon.stub();
+      fakeMediaConnection = {
+        initiateOffer: sinon.stub().resolves({}),
+        reconnect: sinon.stub().resolves({}),
+      };
+      fakeMeeting = {
+        closePeerConnections: sinon.stub().resolves({}),
+        createMediaConnection: sinon.stub().returns(fakeMediaConnection),
+        config: {
+          reconnection: {
+            enabled: true,
+            detection: true,
+            iceReconnectionTimeout: 10000,
+            retry: {
+              times: 2,
+              backOff: {
+                start: 1000,
+                rate: 2,
+              },
+            },
+          },
+        },
+        mediaProperties: {
+          unsetPeerConnection: sinon.stub(),
+          webrtcMediaConnection: fakeMediaConnection,
+        },
+        mediaRequestManagers: {
+          audio: {commit: sinon.stub()},
+          video: {commit: sinon.stub()},
+        },
+        roap: {
+          doTurnDiscovery: sinon.stub().resolves({
+            turnServerInfo: {
+              url: 'fake_turn_url',
+              username: 'fake_turn_username',
+              password: 'fake_turn_password',
+            },
+            turnDiscoverySkippedReason: undefined,
+          }),
+        },
+        statsAnalyzer: {
+          updateMediaConnection: sinon.stub(),
+        },
+        webex: {
+          meetings: {
+            getMeetingByType: sinon.stub().returns(true),
+            syncMeetings: sinon.stub().resolves({}),
+          },
+        },
+      };
+    });
+
+    it('uses correct TURN TLS information on the reconnection', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
+      assert.calledOnce(fakeMediaConnection.reconnect);
+      assert.calledWith(fakeMediaConnection.reconnect, [
+        {
+          urls: 'fake_turn_url',
+          username: 'fake_turn_username',
+          credential: 'fake_turn_password',
+        },
+      ]);
+    });
+
+    it('does not re-request media for non-multistream meetings', async () => {
+      fakeMeeting.isMultistream = false;
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.notCalled(fakeMeeting.mediaRequestManagers.audio.commit);
+      assert.notCalled(fakeMeeting.mediaRequestManagers.video.commit);
+    });
+
+    it('does re-request media for multistream meetings', async () => {
+      fakeMeeting.isMultistream = true;
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.commit);
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.video.commit);
+    });
+  });
+
   /**
    * Currently, testing dependent classes that aren't available at the top
    * level causes testing errors in CI based around related files. Skipping this here until a solution
@@ -30,11 +124,11 @@ describe('plugin-meetings', () => {
               times: 2,
               backOff: {
                 start: 1000,
-                rate: 2
-              }
-            }
-          }
-        }
+                rate: 2,
+              },
+            },
+          },
+        },
       });
     });
 
@@ -53,8 +147,7 @@ describe('plugin-meetings', () => {
         });
 
         it('should resolve the deferred promise', () => {
-          reconnectionManager.iceState.resolve =
-            sinon.spy();
+          reconnectionManager.iceState.resolve = sinon.spy();
           const {resolve} = reconnectionManager.iceState;
 
           reconnectionManager.iceReconnected();

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

@@ -0,0 +1,231 @@
+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';
+
+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('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);
+                    });
+                  });
+            });
+
+            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);
+                    });
+                  });
+            });
+          });
+    });
+});

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

@@ -0,0 +1,102 @@
+import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
+import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
+import { assert } from 'chai';
+
+describe('plugin-meetings', () => {
+    describe('recording-controller tests', () => {
+        describe('recording util tests', () => {
+
+            let locusInfo;
+        
+            beforeEach(() => {
+              locusInfo = {
+                parsedLocus: {
+                  info: {
+                    userDisplayHints: [],
+                  },
+                },
+              };
+            });
+        
+            describe('canUserStart', () => {
+              it('can start recording when the correct display hint is present', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+                assert.equal(RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('canUserPause', () => {
+              it('can pause recording when the correct display hint is present', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+                assert.equal(RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('canUserStop', () => {
+              it('can stop recording when the correct display hint is present', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
+
+                assert.equal(RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('canUserResume', () => {
+              it('can start recording when the correct display hint is present', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+                assert.equal(RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('deriveRecordingStates', () => {
+              it('gets the correct values for a start recording action', () => {
+                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Start), {recording: true, paused: false});
+              });
+
+              it('gets the correct values for a stop recording action', () => {
+                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Stop), {recording: false, paused: false});
+              });
+
+              it('gets the correct values for a resume recording action', () => {
+                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Resume), {recording: true, paused: false});
+              });
+
+              it('gets the correct values for a paused recording action', () => {
+                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Pause), {recording: true, paused: true});
+              });
+            });
+
+            describe('extractLocusId', () => {
+              it('gets the correct id from the url param', () => {
+                assert.equal(RecordingUtil.extractLocusId('test/id'), 'id');
+              });
+
+              it('works with empty string parameters passed', () => {
+                assert.equal(RecordingUtil.extractLocusId(''), '');
+              });
+
+              it('works with no parameters passed', () => {
+                assert.isUndefined(RecordingUtil.extractLocusId(undefined));
+              });
+            });
+        });
+    });
+});