@webex/plugin-meetings 2.29.0 → 2.29.2

package/src/meeting/request.js

@@ -665,4 +665,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       uri
     });
   }
+
+  /**
+   * Send a locus keepAlive (used in lobby)
+   * @param {Object} options
+   * @param {Url} options.keepAliveUrl
+   * @returns {Promise}
+   */
+  keepAlive({
+    keepAliveUrl,
+  }) {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: keepAliveUrl
+    });
+  }
 }

package/src/meeting/util.js

@@ -130,7 +130,8 @@ MeetingUtil.cleanUp = (meeting) => {
       meeting.unsetPeerConnections();
       meeting.reconnectionManager.cleanUp();
     })
-    .then(() => meeting.roap.stop(meeting.correlationId, meeting.roapSeq));
+    .then(() => meeting.roap.stop(meeting.correlationId, meeting.roapSeq))
+    .then(() => meeting.stopKeepAlive());
 };
 
 MeetingUtil.disconnectPhoneAudio = (meeting, phoneUrl) => {

package/src/meeting-info/meeting-info-v2.js

@@ -184,7 +184,7 @@ export default class MeetingInfoV2 {
       webex: this.webex
     });
 
-    if (destinationType.type === _CONVERSATION_URL_ && this.webex.config.meetings.experimental.enableAdhocMeetings) {
+    if (destinationType.type === _CONVERSATION_URL_ && this.webex.config.meetings.experimental.enableAdhocMeetings && this.webex.meetings.preferredWebexSite) {
       return this.createAdhocSpaceMeeting(destinationType.destination);
     }
 

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

@@ -3227,7 +3227,9 @@ describe('plugin-meetings', () => {
       });
       describe('#setUpLocusInfoSelfListener', () => {
         it('listens to the self unadmitted guest event', (done) => {
+          meeting.startKeepAlive = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_UNADMITTED_GUEST', test1);
+          assert.calledOnceWithExactly(meeting.startKeepAlive);
           assert.calledTwice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
@@ -3239,7 +3241,9 @@ describe('plugin-meetings', () => {
           done();
         });
         it('listens to the self admitted guest event', (done) => {
+          meeting.stopKeepAlive = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ADMITTED_GUEST', test1);
+          assert.calledOnceWithExactly(meeting.stopKeepAlive);
           assert.calledTwice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
@@ -4328,6 +4332,157 @@ describe('plugin-meetings', () => {
           });
         });
       });
+
+      describe('#startKeepAlive', () => {
+        let clock;
+        const defaultKeepAliveUrl = 'keep.alive.url';
+        const defaultKeepAliveSecs = 23;
+        const defaultExpectedInterval = (defaultKeepAliveSecs - 1) * 750;
+
+        beforeEach(() => {
+          clock = sinon.useFakeTimers();
+        });
+        afterEach(() => {
+          clock.restore();
+        });
+
+        const progressTime = async (interval) => {
+          await clock.tickAsync(interval);
+          await testUtils.flushPromises();
+        };
+
+        it('startKeepAlive starts the keep alive', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
+
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.joinedWith = {
+            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveSecs: defaultKeepAliveSecs
+          };
+          meeting.startKeepAlive();
+          assert.isNumber(meeting.keepAliveTimerId.id);
+          await testUtils.flushPromises();
+          assert.notCalled(meeting.meetingRequest.keepAlive);
+          await progressTime(defaultExpectedInterval);
+          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+          await progressTime(defaultExpectedInterval);
+          assert.calledTwice(meeting.meetingRequest.keepAlive);
+          assert.alwaysCalledWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+        });
+        it('startKeepAlive handles existing keepAliveTimerId', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
+          logger.warn = sinon.spy();
+
+          meeting.keepAliveTimerId = 7;
+          meeting.joinedWith = {
+            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveSecs: defaultKeepAliveSecs
+          };
+          meeting.startKeepAlive();
+          assert.equal(meeting.keepAliveTimerId, 7);
+          await progressTime(defaultExpectedInterval);
+          assert.notCalled(meeting.meetingRequest.keepAlive);
+        });
+        it('startKeepAlive handles missing keepAliveUrl', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
+          logger.warn = sinon.spy();
+
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.joinedWith = {
+            keepAliveSecs: defaultKeepAliveSecs
+          };
+          meeting.startKeepAlive();
+          assert.isNull(meeting.keepAliveTimerId);
+          await progressTime(defaultExpectedInterval);
+          assert.notCalled(meeting.meetingRequest.keepAlive);
+        });
+        it('startKeepAlive handles missing keepAliveSecs', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
+          logger.warn = sinon.spy();
+
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.joinedWith = {
+            keepAliveUrl: defaultKeepAliveUrl
+          };
+          meeting.startKeepAlive();
+          assert.isNull(meeting.keepAliveTimerId);
+          await progressTime(1);
+          assert.notCalled(meeting.meetingRequest.keepAlive);
+        });
+        it('startKeepAlive handles too low keepAliveSecs', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
+          logger.warn = sinon.spy();
+
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.joinedWith = {
+            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveSecs: 1
+          };
+          meeting.startKeepAlive();
+          assert.isNull(meeting.keepAliveTimerId);
+          await progressTime(1);
+          assert.notCalled(meeting.meetingRequest.keepAlive);
+        });
+        it('failed keepAlive stops the keep alives', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.reject());
+
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.joinedWith = {
+            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveSecs: defaultKeepAliveSecs
+          };
+          meeting.startKeepAlive();
+          assert.isNumber(meeting.keepAliveTimerId.id);
+          await testUtils.flushPromises();
+          assert.notCalled(meeting.meetingRequest.keepAlive);
+          await progressTime(defaultExpectedInterval);
+          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+          assert.isNull(meeting.keepAliveTimerId);
+          await progressTime(defaultExpectedInterval);
+          assert.calledOnce(meeting.meetingRequest.keepAlive);
+        });
+      });
+      describe('#stopKeepAlive', () => {
+        let clock;
+        const defaultKeepAliveUrl = 'keep.alive.url';
+        const defaultKeepAliveSecs = 23;
+        const defaultExpectedInterval = (defaultKeepAliveSecs - 1) * 750;
+
+        beforeEach(() => {
+          clock = sinon.useFakeTimers();
+        });
+        afterEach(() => {
+          clock.restore();
+        });
+
+        const progressTime = async (interval) => {
+          await clock.tickAsync(interval);
+          await testUtils.flushPromises();
+        };
+
+        it('stopKeepAlive stops the keep alive', async () => {
+          meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
+
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.joinedWith = {
+            keepAliveUrl: defaultKeepAliveUrl,
+            keepAliveSecs: defaultKeepAliveSecs
+          };
+          meeting.startKeepAlive();
+          assert.isNumber(meeting.keepAliveTimerId.id);
+          await progressTime(defaultExpectedInterval);
+          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+
+          meeting.stopKeepAlive();
+          assert.isNull(meeting.keepAliveTimerId);
+          await progressTime(defaultExpectedInterval);
+          assert.calledOnce(meeting.meetingRequest.keepAlive);
+        });
+        it('stopKeepAlive handles missing keepAliveTimerId', async () => {
+          assert.isNull(meeting.keepAliveTimerId);
+          meeting.stopKeepAlive();
+        });
+      });
     });
   });
 });

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

@@ -264,5 +264,19 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.uri, `${locusUrl}/end`);
       });
     });
+
+    describe('#keepAlive', () => {
+      it('sends request to keepAlive', async () => {
+        const keepAliveUrl = 'keepAliveURL';
+
+        await meetingsRequest.keepAlive({
+          keepAliveUrl,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'GET');
+        assert.equal(requestParams.uri, keepAliveUrl);
+      });
+    });
   });
 });

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

@@ -43,6 +43,7 @@ describe('plugin-meetings', () => {
       meeting.unsetPeerConnections = sinon.stub();
       meeting.reconnectionManager = {cleanUp: sinon.stub()};
       meeting.roap = {stop: sinon.stub()};
+      meeting.stopKeepAlive = sinon.stub();
     });
 
     afterEach(() => {
@@ -64,6 +65,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.roap.stop);
+        assert.calledOnce(meeting.stopKeepAlive);
       });
     });
 

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -206,6 +206,16 @@ describe('plugin-meetings', () => {
         meetingInfo.createAdhocSpaceMeeting.restore();
       });
 
+      it('should not call createAdhocSpaceMeeting if enableAdhocMeetings toggle is on but preferredWebexSite', async () => {
+        sinon.stub(meetingInfo, 'createAdhocSpaceMeeting').returns(Promise.resolve());
+        webex.meetings.preferredWebexSite = undefined;
+
+        await meetingInfo.fetchMeetingInfo('conversationUrl', _CONVERSATION_URL_);
+
+        assert.notCalled(meetingInfo.createAdhocSpaceMeeting);
+        assert.called(webex.request);
+        meetingInfo.createAdhocSpaceMeeting.restore();
+      });
 
       it('should throw an error MeetingInfoV2AdhocMeetingError if not able to start adhoc meeting for a conversation', async () => {
         webex.config.meetings.experimental.enableAdhocMeetings = true;