@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.160

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

@@ -24,7 +24,7 @@ describe('plugin-meetings', () => {
     };
 
     const configObject = {
-      mediaType: 'video',
+      mediaType: 'video-send',
       remoteRtpResults: {
         id: 'RTCRemoteInboundRtpVideoStream_2411086660',
         timestamp: 1624472676193.79,
@@ -42,12 +42,12 @@ describe('plugin-meetings', () => {
         roundTripTimeMeasurements: 14,
       },
       statsAnalyzerCurrentStats: {
-        audio: {
+        'audio-send': {
           send: {
             currentPacketLossRatio: 8,
           },
         },
-        video: {
+        'video-send': {
           send: {
             currentPacketLossRatio: 10,
           },
@@ -83,7 +83,7 @@ describe('plugin-meetings', () => {
           }),
           sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY),
           sinon.match({
-            mediaType: 'video',
+            mediaType: 'video-send',
             networkQualityScore: 0,
           })
         )

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

@@ -1,50 +1,201 @@
 import {assert} from '@webex/test-helper-chai';
-import Reachability from '@webex/plugin-meetings/src/reachability/';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import Reachability, {ICECandidateResult} 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', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
+  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 tcp is reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'true'}}}, 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 both tcp and udp are reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'true'}, 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 false when both tcp and udp are unreachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'false'}}}, false);
+  it('returns false when reachability result is empty', async () => {
+    await checkIsClusterReachable({x: {}}, false);
   });
 
-  it('returns false when reachability result is empty', () => {
-    checkIsClusterReachable({x: {}}, false);
+  it('returns false when reachability.result item is not there', async () => {
+    await checkIsClusterReachable(undefined, false);
+  });
+});
+
+describe('gatherReachability', () => {
+  let webex;
+
+  beforeEach(async () => {
+    webex = new MockWebex();
+
+    await webex.boundedStorage.put(
+      'Reachability',
+      'reachability.result',
+      JSON.stringify({old: 'results'})
+    );
+  });
+
+  it('stores the reachability', async () => {
+    const reachability = new Reachability(webex);
+
+    const reachabilityResults = {
+      clusters: {
+        clusterId: {
+          udp: 'testUDP',
+        },
+      },
+    };
+    const getClustersResult = {
+      clusters: {clusterId: 'cluster'},
+      joinCookie: {id: 'id'},
+    };
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+    (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults);
+
+    const result = await reachability.gatherReachability();
+
+    assert.equal(result, reachabilityResults);
+
+    const storedResultForReachabilityResult = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.result'
+    );
+    const storedResultForJoinCookie = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.joinCookie'
+    );
+
+    assert.equal(JSON.stringify(result), storedResultForReachabilityResult);
+    assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
   });
 
-  it('returns false when reachability.result item is not there', () => {
-    checkIsClusterReachable(undefined, false);
+  describe('clientMediaIPs', () => {
+    let testingClass: TestReachability;
+
+    class TestReachability extends Reachability {
+      public testParseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
+        return this.parseIceResultsToReachabilityResults(iceResults);
+      }
+      public testAddPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
+        return this.addPublicIP(peerConnection, publicIP);
+      }
+    }
+    beforeEach(() => {
+      testingClass = new TestReachability({webex});
+    });
+
+    it('calls parseIceResultsToReachabilityResults correctly', () => {
+      const res = testingClass.testParseIceResultsToReachabilityResults([
+        {
+          clusterId: 'id1',
+          elapsed: '12312',
+          publicIPs: ['1.1.1.1'],
+        },
+        {
+          clusterId: 'id2',
+          elapsed: null,
+          publicIPs: ['1.1.1.1'],
+        },
+        {
+          clusterId: 'id2',
+          elapsed: '14123',
+          publicIPs: undefined,
+        },
+      ]);
+
+      assert.deepEqual(res, {
+        id1: {
+          tcp: {
+            clientMediaIPs: ['1.1.1.1'],
+            latencyInMilliseconds: '12312',
+            reachable: 'true',
+          },
+          udp: {
+            clientMediaIPs: ['1.1.1.1'],
+            latencyInMilliseconds: '12312',
+            reachable: 'true',
+          },
+        },
+        id2: {
+          tcp: {
+            latencyInMilliseconds: '14123',
+            reachable: 'true',
+          },
+          udp: {
+            latencyInMilliseconds: '14123',
+            reachable: 'true',
+          },
+        },
+      });
+    });
+
+    it('calls addPublicIP correctly with no existing public APIs', () => {
+      const peerConnection = {
+        connectionState: 'not_closed',
+      };
+
+      testingClass.testAddPublicIP(peerConnection as RTCPeerConnection, '1.1.1.1');
+
+      assert.deepEqual(peerConnection, {
+        connectionState: 'not_closed',
+        publicIPs: ['1.1.1.1'],
+      });
+    });
+
+    it('calls addPublicIP correctly with existing public APIs', () => {
+      const peerConnection = {
+        connectionState: 'not_closed',
+        publicIPs: ['2.2.2.2'],
+      };
+
+      testingClass.testAddPublicIP(peerConnection as any, '1.1.1.1');
+
+      assert.deepEqual(peerConnection, {
+        connectionState: 'not_closed',
+        publicIPs: ['2.2.2.2', '1.1.1.1'],
+      });
+    });
+
+    it('calls addPublicIP correctly null publicAPI', () => {
+      const peerConnection = {
+        connectionState: 'not_closed',
+      };
+
+      testingClass.testAddPublicIP(peerConnection as RTCPeerConnection, null);
+
+      assert.deepEqual(peerConnection, {
+        connectionState: 'not_closed',
+        publicIPs: null,
+      });
+    });
   });
 });

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

@@ -0,0 +1,66 @@
+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 ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
+
+
+describe('plugin-meetings/reachability', () => {
+  let reachabilityRequest;
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns('locusUrl'),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+    };
+
+
+    reachabilityRequest = new ReachabilityRequest(webex);
+
+  });
+
+  describe('#getClusters', () => {
+    it('sends a GET request with the correct params', async () => {
+      webex.request = sinon.mock().returns(Promise.resolve({
+        body: {
+          clusterClasses: {
+            hybridMedia: ["clusterId"]
+          },
+          clusters: {"clusterId": {
+            udp: "testUDP"
+          }},
+          joinCookie: {anycastEntryPoint: "aws-eu-west-1"}
+        }
+      }));
+
+      const res = await reachabilityRequest.getClusters();
+
+      const requestParams = webex.request.getCall(0).args[0];
+
+      assert.equal(requestParams.method, 'GET');
+      assert.equal(requestParams.resource, `clusters`);
+      assert.equal(requestParams.api, 'calliopeDiscovery');
+      assert.equal(requestParams.shouldRefreshAccessToken, false);
+
+      assert.deepEqual(requestParams.qs, {
+        JCSupport: 1,
+      });
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+    });
+  });
+});

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

@@ -12,13 +12,16 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('ReconnectionManager.reconnect', () => {
-    it('uses correct TURN TLS information on the new connection', async () => {
-      Metrics.postEvent = sinon.stub();
+    let fakeMediaConnection;
+    let fakeMeeting;
 
-      const fakeMediaConnection = {
+    beforeEach(() => {
+      Metrics.postEvent = sinon.stub();
+      fakeMediaConnection = {
         initiateOffer: sinon.stub().resolves({}),
+        reconnect: sinon.stub().resolves({}),
       };
-      const fakeMeeting = {
+      fakeMeeting = {
         closePeerConnections: sinon.stub().resolves({}),
         createMediaConnection: sinon.stub().returns(fakeMediaConnection),
         config: {
@@ -37,6 +40,11 @@ describe('plugin-meetings', () => {
         },
         mediaProperties: {
           unsetPeerConnection: sinon.stub(),
+          webrtcMediaConnection: fakeMediaConnection,
+        },
+        mediaRequestManagers: {
+          audio: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+          video: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
         },
         roap: {
           doTurnDiscovery: sinon.stub().resolves({
@@ -58,21 +66,46 @@ describe('plugin-meetings', () => {
           },
         },
       };
+    });
 
+    it('uses correct TURN TLS information on the reconnection', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
-      assert.calledOnce(fakeMeeting.closePeerConnections);
-      assert.calledOnce(fakeMeeting.mediaProperties.unsetPeerConnection);
       assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
-      assert.calledOnce(fakeMeeting.createMediaConnection);
-      assert.calledWith(fakeMeeting.createMediaConnection, {
-        url: 'fake_turn_url',
-        username: 'fake_turn_username',
-        password: 'fake_turn_password',
-      });
-      assert.calledOnce(fakeMediaConnection.initiateOffer);
+      assert.calledOnce(fakeMediaConnection.reconnect);
+      assert.calledWith(fakeMediaConnection.reconnect, [
+        {
+          urls: 'fake_turn_url',
+          username: 'fake_turn_username',
+          credential: 'fake_turn_password',
+        },
+      ]);
+    });
+
+    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 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);
     });
   });
 

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);
+                    });
+                  });
+            });
+          });
+    });
+});