@webex/plugin-meetings 2.60.1-next.7 → 2.60.1-next.8

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

@@ -4,16 +4,19 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import MeetingRequest from '@webex/plugin-meetings/src/meeting/request';
 import uuid from 'uuid';
-import { merge } from 'lodash';
+import {merge} from 'lodash';
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
 
-
 describe('plugin-meetings', () => {
   let meetingsRequest;
   let locusDeltaRequestSpy;
   let webex;
-  const geoHintInfoDefaults = {countryCode: 'US', regionCode: 'WEST-COAST', clientAddress: '127.0.0.1'};
+  const geoHintInfoDefaults = {
+    countryCode: 'US',
+    regionCode: 'WEST-COAST',
+    clientAddress: '127.0.0.1',
+  };
   let anonymizeIpSpy;
 
   beforeEach(() => {
@@ -30,6 +33,11 @@ describe('plugin-meetings', () => {
         get: sinon.mock().returns('locusUrl'),
         waitForCatalog: sinon.mock().returns(Promise.resolve({})),
       },
+      device: {
+        config: {
+          installationId: 'installationId',
+        },
+      },
     };
 
     webex.boundedStorage.get = sinon
@@ -179,12 +187,13 @@ describe('plugin-meetings', () => {
     });
 
     describe('#joinMeeting', () => {
-      it('sends /call requets for join', async () => {
+      it('sends /call request for join', async () => {
         const locusUrl = 'locusURL';
         const deviceUrl = 'deviceUrl';
         const correlationId = 'random-uuid';
         const roapMessage = 'roap-message';
         const permissionToken = 'permission-token';
+        const installationId = 'installationId';
 
         await meetingsRequest.joinMeeting({
           locusUrl,
@@ -198,6 +207,7 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.method, 'POST');
         assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
         assert.equal(requestParams.body.device.url, deviceUrl);
+        assert.equal(requestParams.body.device.installationId, installationId);
         assert.equal(requestParams.body.device.countryCode, 'US');
         assert.equal(requestParams.body.permissionToken, 'permission-token');
         assert.equal(requestParams.body.device.regionCode, 'WEST-COAST');
@@ -210,7 +220,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           webex.meetings.geoHintInfo = {};
         });
-    
+
         // reset
         afterEach(() => {
           webex.meetings.geoHintInfo = {...geoHintInfoDefaults};
@@ -222,7 +232,7 @@ describe('plugin-meetings', () => {
           const correlationId = 'random-uuid';
           const roapMessage = 'roap-message';
           const permissionToken = 'permission-token';
-  
+
           await meetingsRequest.joinMeeting({
             locusUrl,
             deviceUrl,
@@ -231,10 +241,10 @@ describe('plugin-meetings', () => {
             permissionToken,
           });
           const requestParams = meetingsRequest.request.getCall(0).args[0];
-  
+
           assert.equal(requestParams.body.device.localIp, undefined);
         });
-      })
+      });
 
       it('sends /call with meetingNumber if inviteeAddress does not exist', async () => {
         const deviceUrl = 'deviceUrl';
@@ -368,16 +378,16 @@ describe('plugin-meetings', () => {
           correlationId,
           roapMessage,
           permissionToken,
-          ipVersion: IP_VERSION.ipv4_and_ipv6
+          ipVersion: IP_VERSION.ipv4_and_ipv6,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
         assert.equal(requestParams.method, 'POST');
         assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
         assert.deepEqual(requestParams.body.clientMediaPreferences, {
-          "joinCookie": {anycastEntryPoint: "aws-eu-west-1"},
-          "preferTranscoding": true,
-          "ipver": 1
+          joinCookie: {anycastEntryPoint: 'aws-eu-west-1'},
+          preferTranscoding: true,
+          ipver: 1,
         });
       });
     });

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

@@ -2,6 +2,7 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import Meetings from '@webex/plugin-meetings';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import {LOCAL_SHARE_ERRORS} from '@webex/plugin-meetings/src/constants';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import {SELF_POLICY, IP_VERSION} from '@webex/plugin-meetings/src/constants';
@@ -1032,5 +1033,97 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('getChangeMeetingFloorErrorPayload', () => {
+      [
+        {
+          reason: LOCAL_SHARE_ERRORS.UNDEFINED,
+          expected: {
+            category: 'signaling',
+            errorCode: 1100,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED,
+          expected: {
+            category: 'signaling',
+            errorCode: 4050,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.NO_MEDIA_FOR_DEVICE,
+          expected: {
+            category: 'media',
+            errorCode: 2048,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.NO_CONFLUENCE_ID,
+          expected: {
+            category: 'signaling',
+            errorCode: 4064,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.CONTENT_SHARING_DISABLED,
+          expected: {
+            category: 'expected',
+            errorCode: 4065,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.LOCUS_PARTICIPANT_DNE,
+          expected: {
+            category: 'signaling',
+            errorCode: 4066,
+          },
+        },
+        {
+          reason: LOCAL_SHARE_ERRORS.CONTENT_REQUEST_WHILE_PENDING_WHITEBOARD,
+          expected: {
+            category: 'expected',
+            errorCode: 4067,
+          },
+        },
+        {
+          reason: 'some unknown reason',
+          expected: {
+            category: 'signaling',
+            errorCode: 1100,
+          },
+        },
+      ].forEach(({reason, expected}) => {
+        const expectedFull = {
+          errorDescription: reason,
+          name: 'locus.response',
+          shownToUser: false,
+          fatal: true,
+          ...expected,
+        };
+        it(`returns expected when reason="${reason}"`, () => {
+          const result = MeetingUtil.getChangeMeetingFloorErrorPayload(reason);
+          assert.equal(result.length, 1);
+
+          const error = result[0];
+          assert.deepEqual(error, expectedFull);
+        });
+      });
+
+      it('properly handles "includes"', () => {
+        const reason = '>>> ' + LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED + ' <<<';
+        const result = MeetingUtil.getChangeMeetingFloorErrorPayload(reason);
+        assert.equal(result.length, 1);
+
+        const error = result[0];
+        assert.deepEqual(error, {
+          category: 'signaling',
+          errorCode: 4050,
+          errorDescription: reason,
+          name: 'locus.response',
+          shownToUser: false,
+          fatal: true,
+        });
+      });
+    });
   });
 });

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

@@ -17,7 +17,7 @@ import StaticConfig from '@webex/plugin-meetings/src/common/config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
-import Meeting from '@webex/plugin-meetings/src/meeting';
+import Meeting, {CallStateForMetrics} from '@webex/plugin-meetings/src/meeting';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Meetings from '@webex/plugin-meetings/src/meetings';
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
@@ -240,6 +240,19 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleTcpReachability', () => {
+      it('should have _toggleTcpReachability', () => {
+        assert.equal(typeof webex.meetings._toggleTcpReachability, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to do TCP reachability', () => {
+          webex.meetings._toggleTcpReachability(true);
+          assert.equal(webex.meetings.config.experimental.enableTcpReachability, true);
+        });
+      });
+    });
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', async () => {
@@ -559,10 +572,10 @@ describe('plugin-meetings', () => {
               });
             });
           });
-          describe('destroy non active locus meetings', () => {
+          describe('when destroying meeting is needed', () => {
             let destroySpy;
 
-            const meetingCollectionMeetings =  {
+            const meetingCollectionMeetings = {
               stillValidLocusMeeting: {
                 locusUrl: 'still-valid-locus-url',
                 sendCallAnalyzerMetrics: sinon.stub(),
@@ -583,21 +596,46 @@ describe('plugin-meetings', () => {
 
             beforeEach(() => {
               destroySpy = sinon.spy(webex.meetings, 'destroy');
-              webex.meetings.meetingCollection.getAll = sinon.stub().returns(meetingCollectionMeetings);
+              webex.meetings.meetingCollection.getAll = sinon
+                .stub()
+                .returns(meetingCollectionMeetings);
               webex.meetings.request.getActiveMeetings = sinon.stub().returns(
                 Promise.resolve({
-                  loci: [
-                    {url: 'still-valid-locus-url'}
-                  ],
+                  loci: [{url: 'still-valid-locus-url'}],
                 })
               );
               MeetingUtil.cleanUp = sinon.stub().returns(Promise.resolve());
             });
-            it('destroy only non active locus meetings and keep active locus meetings and any other non-locus meeting', async () => {
+
+            it('destroy any meeting that has no active locus url if keepOnlyLocusMeetings is not defined', async () => {
               await webex.meetings.syncMeetings();
               assert.calledOnce(webex.meetings.request.getActiveMeetings);
               assert.calledOnce(webex.meetings.meetingCollection.getAll);
               assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting1);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting2);
+              assert.callCount(destroySpy, 3);
+
+              assert.callCount(MeetingUtil.cleanUp, 3);
+            });
+
+            it('destroy any meeting that has no active locus url if keepOnlyLocusMeetings === true', async () => {
+              await webex.meetings.syncMeetings({keepOnlyLocusMeetings: true});
+              assert.calledOnce(webex.meetings.request.getActiveMeetings);
+              assert.calledOnce(webex.meetings.meetingCollection.getAll);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting1);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting2);
+              assert.callCount(destroySpy, 3);
+
+              assert.callCount(MeetingUtil.cleanUp, 3);
+            });
+
+            it('destroy any LOCUS meetings that have no active locus url if keepOnlyLocusMeetings === false', async () => {
+              await webex.meetings.syncMeetings({keepOnlyLocusMeetings: false});
+              assert.calledOnce(webex.meetings.request.getActiveMeetings);
+              assert.calledOnce(webex.meetings.meetingCollection.getAll);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
               assert.callCount(destroySpy, 1);
 
               assert.calledOnce(MeetingUtil.cleanUp);
@@ -680,6 +718,41 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('calls createMeeting, pass the meeting info param and returns its promise', async () => {
+          const meetingInfo = {};
+          await checkCallCreateMeeting(
+            [test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, true, undefined, meetingInfo],
+            [test1, test2, FAKE_USE_RANDOM_DELAY, {}, {correlationId}, true, meetingInfo]
+          );
+        });
+
+        it('calls createMeeting, pass the meeting info and meetingLookupURL param and returns its promise', async () => {
+          const meetingInfo = {};
+          await checkCallCreateMeeting(
+            [
+              test1,
+              test2,
+              FAKE_USE_RANDOM_DELAY,
+              {},
+              correlationId,
+              true,
+              undefined,
+              meetingInfo,
+              'meetingLookupURL',
+            ],
+            [
+              test1,
+              test2,
+              FAKE_USE_RANDOM_DELAY,
+              {},
+              {correlationId},
+              true,
+              meetingInfo,
+              'meetingLookupURL',
+            ]
+          );
+        });
+
         it('calls createMeeting when failOnMissingMeetinginfo is undefined and returns its promise', async () => {
           await checkCallCreateMeeting(
             [test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, undefined],
@@ -1135,23 +1208,35 @@ describe('plugin-meetings', () => {
             type,
             extraParams = {},
             expectedMeetingData = {},
-            sendCAevents = false
+            sendCAevents = false,
+            injectMeetingInfo = false
           ) => {
-            assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
+            if (injectMeetingInfo) {
+              assert.notCalled(webex.meetings.meetingInfo.fetchMeetingInfo);
+            } else {
+              assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
+            }
+
             assert.calledOnce(MeetingsUtil.getMeetingAddedType);
             assert.notCalled(setTimeoutSpy);
             assert.callCount(TriggerProxy.trigger, 5);
-            assert.calledWith(
-              webex.meetings.meetingInfo.fetchMeetingInfo,
-              destination,
-              type,
-              null,
-              null,
-              undefined,
-              undefined,
-              extraParams,
-              {meetingId: meeting.id, sendCAevents}
-            );
+
+            if (injectMeetingInfo) {
+              assert.notCalled(webex.meetings.meetingInfo.fetchMeetingInfo);
+            } else {
+              assert.calledWith(
+                webex.meetings.meetingInfo.fetchMeetingInfo,
+                destination,
+                type,
+                null,
+                null,
+                undefined,
+                undefined,
+                extraParams,
+                {meetingId: meeting.id, sendCAevents}
+              );
+            }
+
             assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
 
             if (expectedMeetingData.permissionToken) {
@@ -1169,6 +1254,12 @@ describe('plugin-meetings', () => {
                 expectedMeetingData.callStateForMetrics
               );
             }
+            if (expectedMeetingData.meetingLookupUrl) {
+              assert.equal(
+                meeting.meetingInfo.meetingLookupUrl,
+                expectedMeetingData.meetingLookupUrl
+              );
+            }
             assert.equal(meeting.destination, destination);
             assert.equal(meeting.destinationType, type);
             assert.calledWith(
@@ -1210,6 +1301,72 @@ describe('plugin-meetings', () => {
             );
           });
 
+          it('accepts injected meeting info', async () => {
+            const meetingInfo = {
+              permissionToken: 'PT',
+              meetingJoinUrl: 'meetingJoinUrl',
+            };
+
+            const meeting = await webex.meetings.createMeeting(
+              'test destination',
+              'test type',
+              false,
+              {},
+              undefined,
+              false,
+              meetingInfo
+            );
+
+            const expectedMeetingData = {
+              ...meetingInfo,
+              correlationId: meeting.id,
+            };
+
+            checkCreateWithoutDelay(
+              meeting,
+              'test destination',
+              'test type',
+              {},
+              expectedMeetingData,
+              false,
+              true
+            );
+          });
+
+          it('accepts injected meeting info with meeting lookup url', async () => {
+            const meetingInfo = {
+              permissionToken: 'PT',
+              meetingJoinUrl: 'meetingJoinUrl',
+            };
+
+            const meeting = await webex.meetings.createMeeting(
+              'test destination',
+              'test type',
+              false,
+              {},
+              undefined,
+              false,
+              meetingInfo,
+              'meetingLookupUrl'
+            );
+
+            const expectedMeetingData = {
+              ...meetingInfo,
+              meetingLookupUrl: 'meetingLookupUrl',
+              correlationId: meeting.id,
+            };
+
+            checkCreateWithoutDelay(
+              meeting,
+              'test destination',
+              'test type',
+              {},
+              expectedMeetingData,
+              false,
+              true
+            );
+          });
+
           [undefined, FAKE_INFO_EXTRA_PARAMS].forEach((infoExtraParams) => {
             const infoExtraParamsProvided = infoExtraParams !== undefined;
 
@@ -1303,6 +1460,8 @@ describe('plugin-meetings', () => {
 
               // When timer expires
               clock.tick(FAKE_TIME_TO_START);
+              await testUtils.flushPromises();
+
               assert.calledWith(
                 webex.meetings.meetingInfo.fetchMeetingInfo,
                 FAKE_LOCUS_MEETING,

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

@@ -210,9 +210,10 @@ describe('gatherReachability', () => {
       xtls: ['xtls1.1', 'xtls1.2'],
       isVideoMesh: false,
     });
+    // cluster 2 is video mesh, so we should not do TCP reachability on it
     assert.calledWith(clusterReachabilityCtorStub, 'cluster 2', {
       udp: ['udp2.1', 'udp2.2'],
-      tcp: ['tcp2.1', 'tcp2.2'],
+      tcp: [],
       xtls: ['xtls2.1', 'xtls2.2'],
       isVideoMesh: true,
     });

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

@@ -81,6 +81,7 @@ describe('plugin-meetings', () => {
       await rm.reconnect();
 
       assert.calledOnce(rm.webex.meetings.syncMeetings);
+      assert.calledWith(rm.webex.meetings.syncMeetings, {keepOnlyLocusMeetings: false});
     });
 
     it('does not sync meetings if it is an unverified guest', async () => {

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

@@ -82,49 +82,35 @@ describe('Roap', () => {
       sinon.restore();
     });
 
-    [
-      {reconnect: true, turnDiscoverySkipped: false, expectEmptyMediaId: false},
-      {reconnect: true, turnDiscoverySkipped: true, expectEmptyMediaId: true},
-      {reconnect: false, turnDiscoverySkipped: false, expectEmptyMediaId: false},
-      {reconnect: false, turnDiscoverySkipped: true, expectEmptyMediaId: false},
-    ].forEach(({reconnect, turnDiscoverySkipped, expectEmptyMediaId}) =>
-      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
-        reconnect ? '' : 'not '
-      }reconnecting and TURN discovery is ${
-        turnDiscoverySkipped ? 'skipped' : 'not skipped'
-      }`, async () => {
-        roap.turnDiscovery.isSkipped.resolves(turnDiscoverySkipped);
-
-        await roap.sendRoapMediaRequest({
-          meeting,
-          sdp: 'sdp',
-          reconnect,
-          seq: 2,
-          tieBreaker: 4294967294,
-        });
+    it(`sends roap OFFER`, async () => {
+      await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        seq: 2,
+        tieBreaker: 4294967294,
+      });
+
+      const expectedRoapMessage = {
+        messageType: 'OFFER',
+        sdps: ['sdp'],
+        version: '2',
+        seq: 2,
+        tieBreaker: 4294967294,
+        headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+      };
 
-        const expectedRoapMessage = {
-          messageType: 'OFFER',
-          sdps: ['sdp'],
-          version: '2',
-          seq: 2,
-          tieBreaker: 4294967294,
-          headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
-        };
-
-        assert.calledOnce(sendRoapStub);
-        assert.calledWith(
-          sendRoapStub,
-          sinon.match({
-            roapMessage: expectedRoapMessage,
-            locusSelfUrl: meeting.selfUrl,
-            mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-            meetingId: meeting.id,
-            locusMediaRequest: meeting.locusMediaRequest,
-          })
-        );
-      })
-    );
+      assert.calledOnce(sendRoapStub);
+      assert.calledWith(
+        sendRoapStub,
+        sinon.match({
+          roapMessage: expectedRoapMessage,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: meeting.mediaId,
+          meetingId: meeting.id,
+          locusMediaRequest: meeting.locusMediaRequest,
+        })
+      );
+    });
 
     it('reads SDP answer from the http response', async () => {
       const roapAnswer = {