@webex/plugin-meetings 3.9.0-next.2 → 3.9.0-next.21

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

@@ -320,9 +320,18 @@ describe('plugin-meetings', () => {
           EVENT_TRIGGERS.MEMBERS_CLEAR,
           {}
         );
+        sinon.restore();
       });
     });
     describe('#locusParticipantsUpdate', () => {
+      beforeEach(() => {
+        sinon.stub(Trigger, 'trigger');
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
       it('should send member update event with session info', () => {
         const members = createMembers({url: url1});
         const fakePayload = {
@@ -343,13 +352,45 @@ describe('plugin-meetings', () => {
           },
           EVENT_TRIGGERS.MEMBERS_UPDATE,
           {
-            delta: {added: [], updated: []},
+            delta: {added: [], updated: [], removedIds: []},
             full: {},
             isReplace: true,
           }
         );
       });
 
+      it('should handle participants being removed', () => {
+        const members = createMembers({url: url1});
+
+        // setup the collection with a fake member
+        members.membersCollection.setAll(fakeMembersCollection);
+        assert.equal(Object.keys(members.membersCollection.getAll()).length, 1);
+
+        // remove the member
+        members.locusParticipantsUpdate({
+          participants: [],
+          removedParticipantIds: ['test1'],
+        });
+
+        assert.equal(Object.keys(members.membersCollection.getAll()).length, 0);
+
+        // check that the event was emitted
+        assert.calledWith(
+          Trigger.trigger,
+          members,
+          {
+            file: 'members',
+            function: 'locusParticipantsUpdate',
+          },
+          EVENT_TRIGGERS.MEMBERS_UPDATE,
+          {
+            delta: {added: [], updated: [], removedIds: ['test1']},
+            full: {},
+            isReplace: false,
+          }
+        );
+      });
+
       describe('handles members with paired devices correctly', () => {
         const runCheck = (propsForUpdate, expectedPropsOnPairedMember) => {
           const members = createMembers({url: url1});
@@ -973,7 +1014,8 @@ describe('plugin-meetings', () => {
         expectedMemberId,
         expectedRequestingParticipantId,
         expectedAlias,
-        expectedLocusUrl
+        expectedLocusUrl,
+        expectedSuffix
       ) => {
         await assert.isFulfilled(resultPromise);
         assert.calledOnceWithExactly(
@@ -981,13 +1023,15 @@ describe('plugin-meetings', () => {
           expectedMemberId,
           expectedRequestingParticipantId,
           expectedAlias,
-          expectedLocusUrl
+          expectedLocusUrl,
+          expectedSuffix
         );
         assert.calledOnceWithExactly(spies.editDisplayNameMember, {
           memberId: expectedMemberId,
           requestingParticipantId: expectedRequestingParticipantId,
           alias: expectedAlias,
           locusUrl: expectedLocusUrl,
+          suffix: expectedSuffix,
         });
         assert.strictEqual(resultPromise, spies.editDisplayNameMember.getCall(0).returnValue);
       };
@@ -1017,6 +1061,31 @@ describe('plugin-meetings', () => {
       });
 
       it('should make the correct request when called with respective parameters', async () => {
+        const requestingParticipantId = uuid.v4();
+        const memberId = uuid.v4();
+        const alias = 'aliasName';
+        const suffix = 'suffixName';
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.editDisplayName(
+          memberId,
+          requestingParticipantId,
+          alias,
+          suffix
+        );
+
+        await checkValid(
+          resultPromise,
+          spies,
+          memberId,
+          requestingParticipantId,
+          alias,
+          url1,
+          suffix
+        );
+      });
+
+      it('should make the correct request when called with respective parameters - no suffix', async () => {
         const requestingParticipantId = uuid.v4();
         const memberId = uuid.v4();
         const alias = 'aliasName';

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

@@ -429,6 +429,61 @@ describe('plugin-meetings', () => {
           },
         });
       });
+
+      it('sends a POST request to the locus endpoint with suffix empty string', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const aliasValue = 'alias';
+
+        const options = {
+          memberId,
+          requestingParticipantId,
+          alias: aliasValue,
+          locusUrl,
+          suffix: '',
+        };
+
+        await membersRequest.editDisplayNameMember(options);
+
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant/${memberId}/alias`,
+          body: {
+            aliasValue,
+            requestingParticipantId,
+            suffixValue: '',
+          },
+        });
+      });
+
+      it('sends a POST request to the locus endpoint with suffixValue', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const aliasValue = 'alias';
+        const suffixValue = 'suffix';
+
+        const options = {
+          memberId,
+          requestingParticipantId,
+          alias: aliasValue,
+          locusUrl,
+          suffix: suffixValue,
+        };
+
+        await membersRequest.editDisplayNameMember(options);
+
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant/${memberId}/alias`,
+          body: {
+            aliasValue,
+            requestingParticipantId,
+            suffixValue,
+          },
+        });
+      });
     });
 
     describe('#moveToLobby', () => {

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

@@ -129,7 +129,32 @@ describe('plugin-meetings', () => {
       });
     });
     describe('#generateEditDisplayNameMemberOptions', () => {
-      it('returns the correct options', () => {
+      it('returns the correct options with suffix when suffix is there', () => {
+        const locusUrl = 'urlTest1';
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const alias = 'alias';
+        const suffix = 'suffix';
+
+        assert.deepEqual(
+          MembersUtil.generateEditDisplayNameMemberOptions(
+            memberId,
+            requestingParticipantId,
+            alias,
+            locusUrl,
+            suffix
+          ),
+          {
+            memberId,
+            requestingParticipantId,
+            alias,
+            locusUrl,
+            suffix,
+          }
+        );
+      });
+
+      it('returns the correct options without suffix when suffix is not there', () => {
         const locusUrl = 'urlTest1';
         const memberId = 'test1';
         const requestingParticipantId = 'test2';
@@ -147,6 +172,7 @@ describe('plugin-meetings', () => {
             requestingParticipantId,
             alias,
             locusUrl,
+            suffix: undefined,
           }
         );
       });
@@ -306,7 +332,7 @@ describe('plugin-meetings', () => {
         const options = {
           invitee: {
             phoneNumber: '1234567890',
-            isInternalNumber: false
+            isInternalNumber: false,
           },
           alertIfActive: false,
         };
@@ -315,7 +341,7 @@ describe('plugin-meetings', () => {
           invitees: [
             {
               address: '1234567890',
-              isInternalNumber: false
+              isInternalNumber: false,
             },
           ],
           alertIfActive: false,
@@ -417,16 +443,10 @@ describe('plugin-meetings', () => {
         const memberId = 'test';
         const invitee = {memberId, isInternalNumber: false};
 
-        assert.deepEqual(
-          MembersUtil.cancelInviteByMemberIdOptions(
-            invitee,
-            locusUrl
-          ),
-          {
-            invitee,
-            locusUrl,
-          }
-        );
+        assert.deepEqual(MembersUtil.cancelInviteByMemberIdOptions(invitee, locusUrl), {
+          invitee,
+          locusUrl,
+        });
       });
     });
 
@@ -436,7 +456,7 @@ describe('plugin-meetings', () => {
         const memberId = 'test';
         const options = {
           locusUrl,
-          invitee: {memberId, isInternalNumber: false}
+          invitee: {memberId, isInternalNumber: false},
         };
         const body = {
           actionType: 'REMOVE',
@@ -452,5 +472,87 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#editDisplayNameMemberRequestParams', () => {
+      it('returns the correct params when suffix is available', () => {
+        const locusUrl = 'TestLocusUrl1';
+        const memberId = 'test1';
+        const alias = 'alias1';
+        const requestingParticipantId = '23131';
+        const suffix = 'suffix1';
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+          alias,
+          requestingParticipantId,
+          suffix,
+        };
+
+        const uri = `${locusUrl}/participant/${memberId}/alias`;
+
+        assert.deepEqual(MembersUtil.editDisplayNameMemberRequestParams(options), {
+          method: HTTP_VERBS.POST,
+          uri,
+          body: {
+            aliasValue: alias,
+            requestingParticipantId,
+            suffixValue: suffix,
+          },
+        });
+      });
+
+      it('returns the correct params when suffix is not available', () => {
+        const locusUrl = 'TestLocusUrl2';
+        const memberId = 'test2';
+        const alias = 'alias2';
+        const requestingParticipantId = '12345';
+
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+          alias,
+          requestingParticipantId,
+        };
+
+        const uri = `${locusUrl}/participant/${memberId}/alias`;
+
+        assert.deepEqual(MembersUtil.editDisplayNameMemberRequestParams(options), {
+          method: HTTP_VERBS.POST,
+          uri,
+          body: {
+            aliasValue: alias,
+            requestingParticipantId,
+          },
+        });
+      });
+
+      it('returns the correct params when suffix is empty string', () => {
+        const locusUrl = 'TestLocusUrl3';
+        const memberId = 'test3';
+        const alias = 'alias3';
+        const requestingParticipantId = '322424';
+        const suffix = '';
+
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+          alias,
+          suffix,
+          requestingParticipantId,
+        };
+
+        const uri = `${locusUrl}/participant/${memberId}/alias`;
+
+        assert.deepEqual(MembersUtil.editDisplayNameMemberRequestParams(options), {
+          method: HTTP_VERBS.POST,
+          uri,
+          body: {
+            aliasValue: alias,
+            requestingParticipantId,
+            suffixValue: suffix,
+          },
+        });
+      });
+    });
   });
 });

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

@@ -3,15 +3,14 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import EventEmitter from 'events';
 import testUtils from '../../../utils/testUtils';
-import Reachability, {
-  ReachabilityResultsForBackend,
-} from '@webex/plugin-meetings/src/reachability/';
+import Reachability from '@webex/plugin-meetings/src/reachability/';
 import {ClusterNode} from '../../../../src/reachability/request';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+import { ReachabilityResultsForBackend } from '@webex/plugin-meetings/src/reachability/reachability.types';
 
 describe('isAnyPublicClusterReachable', () => {
   let webex;
@@ -836,6 +835,162 @@ describe('gatherReachability', () => {
       },
     },
     // ========================================================================
+    {
+      title: '2 clusters: one with multiple urls, reachability should resolve after the first result for each protocol is ready',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1-1', 'udp-url1-2'],
+          tcp: ['tcp-url1-1', 'tcp-url1-2'],
+          xtls: ['xtls-url1-1', 'xtls-url1-2'],
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: ['udp-url2'],
+          tcp: ['tcp-url2'],
+          xtls: ['xtls-url2'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        // results are only for the first url for each protocol not the 2nd one
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 100,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 20,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 110,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 220,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 20},
+          tcp: {result: 'reachable', latencyInMilliseconds: 110},
+          xtls: {result: 'reachable', latencyInMilliseconds: 220},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 20,
+        public_udp_average: 15,
+        public_tcp_min: 100,
+        public_tcp_max: 110,
+        public_tcp_average: 105,
+        public_xtls_min: 200,
+        public_xtls_max: 220,
+        public_xtls_average: 210,
+      },
+    },
+    // ========================================================================
+    {
+      title: '1 cluster with zero urls for TCP, reachability should resolve after the first result for each protocol is ready without waiting for TCP',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1'],
+          tcp: [],
+          xtls: ['xtls-url1'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'untested'},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 10,
+        public_udp_average: 10,
+        public_tcp_min: -1,
+        public_tcp_max: -1,
+        public_tcp_average: -1,
+        public_xtls_min: 200,
+        public_xtls_max: 200,
+        public_xtls_average: 200,
+      },
+    },
+    // ========================================================================
     {
       title: '2 clusters: both with no results at all',
       waitShortTimeout: 'public',

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

@@ -321,7 +321,7 @@ describe('TurnDiscovery', () => {
             result,
             undefined,
             undefined,
-            'failure: Unexpected token o in JSON at position 1'
+            `failure: Unexpected token 'o', "not a json" is not valid JSON`
           );
           checkFailureMetricsSent();
         });
@@ -568,7 +568,7 @@ describe('TurnDiscovery', () => {
       // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
 
-      // simulate the response with some empty urls, normally there would be just 1, but we put more just for the sake of testing 
+      // simulate the response with some empty urls, normally there would be just 1, but we put more just for the sake of testing
       td.handleTurnDiscoveryResponse(
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
@@ -960,7 +960,7 @@ describe('TurnDiscovery', () => {
 
       assert.deepEqual(result, {
         turnServerInfo: undefined,
-        turnDiscoverySkippedReason: 'failure: Unexpected token o in JSON at position 1',
+        turnDiscoverySkippedReason: `failure: Unexpected token 'o', "not a json" is not valid JSON`,
       });
     });