@webex/plugin-meetings 2.59.8 → 2.60.0-next.2

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

@@ -0,0 +1,68 @@
+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';
+import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+
+
+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(IP_VERSION.only_ipv4);
+
+      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,
+        ipver: 4,
+      });
+      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

@@ -2,9 +2,8 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import Media from '@webex/plugin-meetings/src/media/index';
-
-import ReconnectionManager from '../../../../src/reconnection-manager';
+import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
+import { RECONNECTION } from '../../../../src/constants';
 
 const {assert} = chai;
 
@@ -12,10 +11,18 @@ chai.use(chaiAsPromised);
 sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
-  describe('ReconnectionManager.reconnectMedia', () => {
-    it('uses correct TURN TLS information on reInitiatePeerconnection', async () => {
-      const fakeMeeting = {
-        setRemoteStream: sinon.stub().resolves({}),
+  describe('ReconnectionManager.reconnect', () => {
+    let fakeMediaConnection;
+    let fakeMeeting;
+
+    beforeEach(() => {
+      fakeMediaConnection = {
+        initiateOffer: sinon.stub().resolves({}),
+        reconnect: sinon.stub().resolves({}),
+      };
+      fakeMeeting = {
+        closePeerConnections: sinon.stub().resolves({}),
+        createMediaConnection: sinon.stub().returns(fakeMediaConnection),
         config: {
           reconnection: {
             enabled: true,
@@ -32,8 +39,11 @@ describe('plugin-meetings', () => {
         },
         mediaProperties: {
           unsetPeerConnection: sinon.stub(),
-          reInitiatePeerconnection: sinon.stub().resolves({}),
-          peerConnection: sinon.stub(),
+          webrtcMediaConnection: fakeMediaConnection,
+        },
+        mediaRequestManagers: {
+          audio: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+          video: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
         },
         roap: {
           doTurnDiscovery: sinon.stub().resolves({
@@ -44,41 +54,129 @@ describe('plugin-meetings', () => {
             },
             turnDiscoverySkippedReason: undefined,
           }),
-          sendRoapMediaRequest: sinon.stub().resolves({}),
         },
         statsAnalyzer: {
-          updatePeerconnection: sinon.stub().returns(Promise.resolve()),
+          updateMediaConnection: sinon.stub(),
         },
         webex: {
+          credentials: {
+            isUnverifiedGuest: false,
+          },
           meetings: {
             getMeetingByType: sinon.stub().returns(true),
             syncMeetings: sinon.stub().resolves({}),
           },
+          internal: {
+            newMetrics: {
+              submitClientEvent: sinon.stub()
+            }
+          }
         },
       };
+    });
 
-      Media.attachMedia = sinon.stub().resolves({});
+    it('syncs meetings if it is not an unverified guest', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 
-      rm.iceState.disconnected = true;
+      await rm.reconnect();
 
-      await rm.reconnectMedia();
+      assert.calledOnce(rm.webex.meetings.syncMeetings);
+    });
+
+    it('does not sync meetings if it is an unverified guest', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      rm.webex.credentials.isUnverifiedGuest = true;
+
+      await rm.reconnect();
+
+      assert.notCalled(rm.webex.meetings.syncMeetings);
+    });
+
+    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(fakeMeeting.mediaProperties.reInitiatePeerconnection);
-      assert.calledWith(fakeMeeting.mediaProperties.reInitiatePeerconnection, {
-        url: 'fake_turn_url',
-        username: 'fake_turn_username',
-        password: 'fake_turn_password',
+      assert.calledWith(fakeMeeting.roap.doTurnDiscovery, fakeMeeting, true, true);
+      assert.calledOnce(fakeMediaConnection.reconnect);
+      assert.calledWith(fakeMediaConnection.reconnect, [
+        {
+          urls: 'fake_turn_url',
+          username: 'fake_turn_username',
+          credential: 'fake_turn_password',
+        },
+      ]);
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: rm.meeting.id,
+        },
       });
     });
+
+    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);
+    });
+
+
+    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,
+          },
+        });
+      }
+    });
   });
+
   /**
    * 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
    * to this problem is generated.
    */
-  describe.skip('ReconnectionManager', () => {
+  describe('ReconnectionManager', () => {
     let reconnectionManager;
 
     beforeEach(() => {
@@ -171,10 +269,11 @@ describe('plugin-meetings', () => {
           assert.isTrue(reconnectionManager.iceState.disconnected);
         });
 
-        it('should return a promise that rejects after a duration', () => {
+        it('should return a promise that rejects after a duration', (done) => {
           reconnectionManager.iceState.timeoutDuration = 100;
 
-          return assert.isRejected(reconnectionManager.waitForIceReconnect());
+          assert.isRejected(reconnectionManager.waitForIceReconnect());
+          done();
         });
 
         it('should resolve return a resolved promise when triggered', () => {
@@ -201,6 +300,30 @@ describe('plugin-meetings', () => {
           assert.isTrue(reconnectionManager.iceState.disconnected);
         });
       });
+
+      describe('setStatus()', () => {
+        beforeEach(() => {
+          reconnectionManager.status = RECONNECTION.STATE.DEFAULT_STATUS;
+        });
+
+        it('should correctly change status to in progress', () => {
+          reconnectionManager.setStatus(RECONNECTION.STATE.IN_PROGRESS);
+
+          assert.equal(reconnectionManager.status, RECONNECTION.STATE.IN_PROGRESS);
+        });
+
+        it('should correctly change status to complete', () => {
+          reconnectionManager.setStatus(RECONNECTION.STATE.COMPLETE);
+
+          assert.equal(reconnectionManager.status, RECONNECTION.STATE.COMPLETE);
+        });
+
+        it('should correctly change status to failure', () => {
+          reconnectionManager.setStatus(RECONNECTION.STATE.FAILURE);
+
+          assert.equal(reconnectionManager.status, RECONNECTION.STATE.FAILURE);
+        });
+      });
     });
   });
 });