@webex/plugin-meetings 2.60.1-next.13 → 2.60.1-next.14

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

@@ -3853,6 +3853,7 @@ describe('plugin-meetings', () => {
           meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
           meeting.mediaProperties.shareVideoStream = {};
           meeting.mediaProperties.mediaDirection.sendShare = true;
+          meeting.deviceUrl = 'deviceUrl.com';
           meeting.state = 'JOINED';
           meeting.localShareInstanceId = '1234-5678';
         });
@@ -3868,6 +3869,15 @@ describe('plugin-meetings', () => {
           await share;
           assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
 
+          assert.calledWith(meeting.meetingRequest.changeMeetingFloor, {
+            disposition: FLOOR_ACTION.GRANTED,
+            personUrl: url1,
+            deviceUrl: 'deviceUrl.com',
+            uri: url1,
+            resourceUrl: undefined,
+            shareInstanceId: '1234-5678',
+          });
+
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.share.floor-grant.request',
             payload: {mediaType: 'share', shareInstanceId: '1234-5678'},
@@ -3887,6 +3897,15 @@ describe('plugin-meetings', () => {
             assert.equal(err, error);
           });
 
+          assert.calledWith(meeting.meetingRequest.changeMeetingFloor, {
+            disposition: 'GRANTED',
+            personUrl: url1,
+            deviceUrl: 'deviceUrl.com',
+            uri: url1,
+            resourceUrl: undefined,
+            shareInstanceId: '1234-5678',
+          });
+
           assert.calledWith(getChangeMeetingFloorErrorPayloadSpy, 'forced');
 
           // ensure the expected CA share metric is submitted
@@ -7751,11 +7770,21 @@ describe('plugin-meetings', () => {
           meeting.locusInfo.self = {url: url2};
           meeting.mediaProperties = {mediaDirection: {sendShare: true}};
           meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
+          (meeting.deviceUrl = 'deviceUrl.com'), (meeting.localShareInstanceId = '1234-5678');
         });
         it('should call changeMeetingFloor()', async () => {
           meeting.screenShareFloorState = 'GRANTED';
           const share = meeting.releaseScreenShareFloor();
 
+          assert.calledWith(meeting.meetingRequest.changeMeetingFloor, {
+            disposition: FLOOR_ACTION.RELEASED,
+            personUrl: url2,
+            deviceUrl: 'deviceUrl.com',
+            uri: url1,
+            resourceUrl: undefined,
+            shareInstanceId: '1234-5678',
+          });
+
           assert.exists(share.then);
           await share;
           assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
@@ -9120,6 +9149,7 @@ describe('plugin-meetings', () => {
             meeting.locusInfo.mediaShares = [{name: 'whiteboard', url: url1}];
             meeting.locusInfo.self = {url: url1};
             meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
+            meeting.deviceUrl = 'deviceUrl.com';
           });
           it('should have #startWhiteboardShare', () => {
             assert.exists(meeting.startWhiteboardShare);
@@ -9133,6 +9163,14 @@ describe('plugin-meetings', () => {
             await whiteboardShare;
             assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
 
+            assert.calledWith(meeting.meetingRequest.changeMeetingFloor, {
+              disposition: FLOOR_ACTION.GRANTED,
+              personUrl: url1,
+              deviceUrl: 'deviceUrl.com',
+              uri: url1,
+              resourceUrl: {channelUrl: url2},
+            });
+
             // ensure the CA share metric is submitted
             assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
               name: 'client.share.initiated',
@@ -9149,12 +9187,20 @@ describe('plugin-meetings', () => {
             meeting.locusInfo.mediaShares = [{name: 'whiteboard', url: url1}];
             meeting.locusInfo.self = {url: url1};
             meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
+            meeting.deviceUrl = 'deviceUrl.com';
           });
           it('should stop the whiteboard share', async () => {
             const whiteboardShare = meeting.stopWhiteboardShare();
 
             assert.exists(whiteboardShare.then);
             await whiteboardShare;
+
+            assert.calledWith(meeting.meetingRequest.changeMeetingFloor, {
+              disposition: FLOOR_ACTION.RELEASED,
+              personUrl: url1,
+              deviceUrl: 'deviceUrl.com',
+              uri: url1,
+            });
             assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
           });
         });

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

@@ -755,6 +755,7 @@ describe('plugin-meetings', () => {
         deviceUrl: 'deviceUrl',
         resourceId: 'resourceId',
         resourceUrl: 'resourceUrl',
+        shareInstanceId: '12345',
         uri: 'optionsUrl',
         annotationInfo: {
           version: '1',
@@ -768,6 +769,7 @@ describe('plugin-meetings', () => {
           version: '1',
         },
         floor: {
+          shareInstanceId: '12345',
           beneficiary: {
             devices: [
               {

package/test/unit/spec/meetings/utils.js

@@ -162,9 +162,24 @@ describe('plugin-meetings', () => {
     });
 
     describe("#handleRoapMercury", () => {
-      it('it sends the correct behaviour metric', () => {
-        const roapMessageReceived = sinon.stub();
-        const envelope = {
+      let envelope;
+      let meetingCollection;
+      let roapMessageReceived;
+      let handleTurnDiscoveryResponse;
+      let meeting;
+
+      beforeEach(() => {
+        roapMessageReceived = sinon.stub();
+        handleTurnDiscoveryResponse = sinon.stub();
+
+        meeting = {
+          id: 'meeting-id',
+          roapMessageReceived,
+          roap: {
+            turnDiscovery: {handleTurnDiscoveryResponse}
+          }
+        };
+        envelope = {
           data: {
             message:{
               seq: "seq",
@@ -178,13 +193,12 @@ describe('plugin-meetings', () => {
             eventType: 'locus.message.roap',
           }
         };
-        const meetingCollection = {
-          getByKey: () => ({
-            id: 'meeting-id',
-            roapMessageReceived
-          })
+        meetingCollection = {
+          getByKey: () => meeting
         };
+      });
 
+      it('it sends the correct behaviour metric', () => {
         MeetingsUtil.handleRoapMercury(envelope, meetingCollection);
         assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_MERCURY_EVENT_RECEIVED,  {
           correlation_id: 'correlationId',
@@ -203,6 +217,19 @@ describe('plugin-meetings', () => {
         })
 
       });
+
+      it('calls handleTurnDiscoveryResponse for TURN_DISCOVERY_RESPONSE', () => {
+        envelope.data.message.messageType = 'TURN_DISCOVERY_RESPONSE';
+        delete envelope.data.message.sdps;
+        MeetingsUtil.handleRoapMercury(envelope, meetingCollection);
+        assert.calledWith(meeting.roap.turnDiscovery.handleTurnDiscoveryResponse, {
+          seq: "seq",
+          messageType: 'TURN_DISCOVERY_RESPONSE',
+          errorType: 'errorType',
+          tieBreaker: 'tieBreaker',
+          errorCause: 'errorCause',
+        }, 'from mercury')
+      });
     })
   });
 

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

@@ -128,6 +128,11 @@ describe('gatherReachability', () => {
       'reachability.result',
       JSON.stringify({old: 'results'})
     );
+    await webex.boundedStorage.put(
+      'Reachability',
+      'reachability.joinCookie',
+      JSON.stringify({old: 'joinCookie'})
+    );
   });
 
   afterEach(() => {
@@ -169,6 +174,75 @@ describe('gatherReachability', () => {
     assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
   });
 
+  it('keeps the stored reachability from previous call to gatherReachability if getClusters fails', 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().throws();
+
+    const result = await reachability.gatherReachability();
+
+    assert.empty(result);
+
+    const storedResultForReachabilityResult = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.result'
+    );
+    const storedResultForJoinCookie = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.joinCookie'
+    );
+
+    assert.equal(JSON.stringify({old: 'results'}), storedResultForReachabilityResult);
+    assert.equal(JSON.stringify({old: 'joinCookie'}), storedResultForJoinCookie);
+  });
+
+  it('keeps the stored reachability from previous call to gatherReachability if performReachabilityChecks fails', 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).performReachabilityChecks = sinon.stub().throws();
+
+    const result = await reachability.gatherReachability();
+
+    assert.empty(result);
+
+    const storedResultForReachabilityResult = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.result'
+    );
+    const storedResultForJoinCookie = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.joinCookie'
+    );
+
+    assert.equal(JSON.stringify({old: 'results'}), storedResultForReachabilityResult);
+    assert.equal(JSON.stringify({old: 'joinCookie'}), storedResultForJoinCookie);
+  });
+
   it('starts ClusterReachability on each media cluster', async () => {
     webex.config.meetings.experimental = {enableTcpReachability: true};
 

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

@@ -4,6 +4,8 @@ import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import { RECONNECTION } from '../../../../src/constants';
+import LoggerProxy from '../../../../src/common/logs/logger-proxy';
+import LoggerConfig from '../../../../src/common/logs/logger-config';
 
 const {assert} = chai;
 
@@ -12,8 +14,16 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('ReconnectionManager.reconnect', () => {
+    const sandbox = sinon.createSandbox();
     let fakeMediaConnection;
     let fakeMeeting;
+    let loggerSpy;
+
+    before(() => {
+      LoggerConfig.set({ enable: false });
+      LoggerProxy.set();
+      loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
+    });
 
     beforeEach(() => {
       fakeMediaConnection = {
@@ -65,6 +75,7 @@ describe('plugin-meetings', () => {
           meetings: {
             getMeetingByType: sinon.stub().returns(true),
             syncMeetings: sinon.stub().resolves({}),
+            startReachability: sinon.stub().resolves({}),
           },
           internal: {
             newMetrics: {
@@ -75,6 +86,10 @@ describe('plugin-meetings', () => {
       };
     });
 
+    afterEach(() => {
+      sandbox.reset();
+    });
+
     it('syncs meetings if it is not an unverified guest', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 
@@ -94,6 +109,27 @@ describe('plugin-meetings', () => {
       assert.notCalled(rm.webex.meetings.syncMeetings);
     });
 
+    it('calls startReachability on reconnect', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(rm.webex.meetings.startReachability);
+    });
+
+    it('continues with reconnection attempt if startReachability throws an error', async () => {
+      const reachabilityError = new Error();
+      fakeMeeting.webex.meetings.startReachability = sinon.stub().throws(reachabilityError);
+
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(rm.webex.meetings.startReachability);
+      assert.calledWith(loggerSpy, 'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ', reachabilityError);
+      assert.calledWith(loggerSpy, 'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.');
+    });
+
     it('uses correct TURN TLS information on the reconnection', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 
@@ -142,7 +178,6 @@ describe('plugin-meetings', () => {
       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;