@webex/plugin-meetings 3.3.1 → 3.4.0

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

@@ -58,4 +58,130 @@ describe('Meeting metrics', () => {
       });
     });
   });
+
+  describe('prepareMetricFields', () => {
+    it('handles empty objects correctly', () => {
+      const result = metrics.prepareMetricFields({});
+
+      assert.deepEqual(result, {});
+    });
+
+    it('handles literal values correctly', () => {
+      assert.deepEqual(metrics.prepareMetricFields('any string'), {value: 'any string'});
+      assert.deepEqual(metrics.prepareMetricFields(999), {value: 999});
+      assert.deepEqual(metrics.prepareMetricFields(null), {value: null});
+      assert.deepEqual(metrics.prepareMetricFields(true), {value: true});
+      assert.deepEqual(metrics.prepareMetricFields(false), {value: false});
+    });
+
+    it('handles simple objects correctly', () => {
+      const result = metrics.prepareMetricFields({
+        someStringProp: 'some string',
+        numberProp: 100,
+        booleanPropFalse: false,
+        booleanPropTrue: true,
+      });
+
+      assert.deepEqual(result, {
+        someStringProp: 'some string',
+        numberProp: 100,
+        booleanPropFalse: false,
+        booleanPropTrue: true,
+      });
+    });
+
+    it('handles nested objects correctly', () => {
+      const result = metrics.prepareMetricFields({
+        someStringProp: 'some string',
+        nestedObject: {
+          stringProp: 'another string',
+          numberProp: 1234,
+          deepObject: {
+            oneMoreString: 'deep nested string',
+            someBoolean: true,
+            oneMoreNumber: 10,
+          },
+        },
+      });
+
+      assert.deepEqual(result, {
+        someStringProp: 'some string',
+        nestedObject_stringProp: 'another string',
+        nestedObject_numberProp: 1234,
+        nestedObject_deepObject_oneMoreString: 'deep nested string',
+        nestedObject_deepObject_someBoolean: true,
+        nestedObject_deepObject_oneMoreNumber: 10,
+      });
+    });
+
+    it('handles arrays correctly', () => {
+      const result = metrics.prepareMetricFields(['a string', 10, true, false, {id: 'object id'}]);
+
+      assert.deepEqual(result, {
+        0: 'a string',
+        1: 10,
+        2: true,
+        3: false,
+        '4_id': 'object id',
+      });
+    });
+
+    it('handles arrays nested in objects correctly', () => {
+      const result = metrics.prepareMetricFields({
+        something: 10,
+        anObject: {
+          someArray: ['a string', 10, true, false, {id: 'object id'}],
+        },
+      });
+
+      assert.deepEqual(result, {
+        something: 10,
+        anObject_someArray_0: 'a string',
+        anObject_someArray_1: 10,
+        anObject_someArray_2: true,
+        anObject_someArray_3: false,
+        anObject_someArray_4_id: 'object id',
+      });
+    });
+
+    it('handles arrays nested in arrays correctly', () => {
+      const result = metrics.prepareMetricFields({
+        something: 10,
+        topLevelArray: [
+          [1, 2, 'three', {prop1: '1st prop of object 1', prop2: '2nd prop of object 1'}],
+          [10, 20, 'thirty', {prop1: '1st prop of object 2', prop2: '2nd prop of object 2'}],
+        ],
+      });
+
+      assert.deepEqual(result, {
+        something: 10,
+        topLevelArray_0_0: 1,
+        topLevelArray_0_1: 2,
+        topLevelArray_0_2: 'three',
+        topLevelArray_0_3_prop1: '1st prop of object 1',
+        topLevelArray_0_3_prop2: '2nd prop of object 1',
+        topLevelArray_1_0: 10,
+        topLevelArray_1_1: 20,
+        topLevelArray_1_2: 'thirty',
+        topLevelArray_1_3_prop1: '1st prop of object 2',
+        topLevelArray_1_3_prop2: '2nd prop of object 2',
+      });
+    });
+
+    it('prepends the prefix', () => {
+      const result = metrics.prepareMetricFields({
+        someStringProp: 'a string',
+        numberProp: 111,
+        booleanPropFalse: false,
+        booleanPropTrue: true,
+      }, 'testPrefix');
+
+      assert.deepEqual(result, {
+        testPrefix_someStringProp: 'a string',
+        testPrefix_numberProp: 111,
+        testPrefix_booleanPropFalse: false,
+        testPrefix_booleanPropTrue: true,
+      });
+    })
+  });
 });

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -4,7 +4,7 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import {getMaxFs} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import FakeTimers from '@sinonjs/fake-timers';
-import * as mediaCore from '@webex/internal-media-core';
+import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import { expect } from 'chai';
 
 type ExpectedActiveSpeaker = {
@@ -978,7 +978,7 @@ describe('MediaRequestManager', () => {
     beforeEach(() => {
       sendMediaRequestsCallback.resetHistory();
       getRecommendedMaxBitrateForFrameSizeSpy = sinon.spy(
-        mediaCore,
+        InternalMediaCoreModule,
         'getRecommendedMaxBitrateForFrameSize'
       );
     });

package/test/unit/spec/personal-meeting-room/personal-meeting-room.js

@@ -5,7 +5,7 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {_PERSONAL_ROOM_} from '@webex/plugin-meetings/src/constants';
+import {DESTINATION_TYPE} from '@webex/plugin-meetings/src/constants';
 import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
 
 describe('personal-meeting-room', () => {
@@ -23,7 +23,7 @@ describe('personal-meeting-room', () => {
     it('returns personal meeting room info', async () => {
       await pmr.get();
       assert.calledOnce(meetingInfo.fetchMeetingInfo);
-      assert.calledWith(meetingInfo.fetchMeetingInfo, {type: _PERSONAL_ROOM_});
+      assert.calledWith(meetingInfo.fetchMeetingInfo, {type: DESTINATION_TYPE.PERSONAL_ROOM});
     });
   });
 });

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

@@ -4,15 +4,28 @@ import sinon from 'sinon';
 import testUtils from '../../../utils/testUtils';
 
 // packages/@webex/plugin-meetings/test/unit/spec/reachability/clusterReachability.ts
-import {ClusterReachability} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+import {
+  ClusterReachability,
+  ResultEventData,
+  Events,
+  ClientMediaIpsUpdatedEventData,
+} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
   let clusterReachability;
   let fakePeerConnection;
 
+  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
+    [Events.resultReady]: [],
+    [Events.clientMediaIpsUpdated]: [],
+  };
   const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
 
+  const resetEmittedEvents = () => {
+    emittedEvents[Events.resultReady].length = 0;
+    emittedEvents[Events.clientMediaIpsUpdated].length = 0;
+  };
   beforeEach(() => {
     fakePeerConnection = {
       createOffer: sinon.stub().resolves(FAKE_OFFER),
@@ -30,6 +43,16 @@ describe('ClusterReachability', () => {
       tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
+
+    resetEmittedEvents();
+
+    clusterReachability.on(Events.resultReady, (data: ResultEventData) => {
+      emittedEvents[Events.resultReady].push(data);
+    });
+
+    clusterReachability.on(Events.clientMediaIpsUpdated, (data: ClientMediaIpsUpdatedEventData) => {
+      emittedEvents[Events.clientMediaIpsUpdated].push(data);
+    });
   });
 
   afterEach(() => {
@@ -98,6 +121,10 @@ describe('ClusterReachability', () => {
       tcp: {result: 'untested'},
       xtls: {result: 'untested'},
     });
+
+    // verify that no events were emitted
+    assert.deepEqual(emittedEvents[Events.resultReady], []);
+    assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
   });
 
   describe('#start', () => {
@@ -124,8 +151,12 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
+      clusterReachability.abort();
       await promise;
+
+      // verify that no events were emitted
+      assert.deepEqual(emittedEvents[Events.resultReady], []);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
     it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
@@ -134,14 +165,44 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
 
+      // check the right events were emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 100,
+        clientMediaIPs: ['somePublicIp'],
+      });
+
+      // clientMediaIpsUpdated shouldn't be emitted, because the IP is already passed in the resultReady event
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
 
+      // check the right event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 2);
+      assert.deepEqual(emittedEvents[Events.resultReady][1], {
+        protocol: 'tcp',
+        result: 'reachable',
+        latencyInMilliseconds: 200,
+      });
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      // check the right event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 3);
+      assert.deepEqual(emittedEvents[Events.resultReady][2], {
+        protocol: 'xtls',
+        result: 'reachable',
+        latencyInMilliseconds: 300,
+      });
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -151,13 +212,17 @@ describe('ClusterReachability', () => {
       });
     });
 
-    it('times out correctly', async () => {
+    it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
       // progress time without any candidates
-      await clock.tickAsync(3000);
+      clusterReachability.abort();
       await promise;
 
+      // verify that no events were emitted
+      assert.deepEqual(emittedEvents[Events.resultReady], []);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
+
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
@@ -165,22 +230,26 @@ describe('ClusterReachability', () => {
       });
     });
 
-    it('times out correctly for video mesh nodes', async () => {
-      clusterReachability = new ClusterReachability('testName', {
-        isVideoMesh: true,
-        udp: ['stun:udp1', 'stun:udp2'],
-        tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-        xtls: ['stun:xtls1.webex.com', 'stun:xtls1.webex.com:443'],
-      });
-
+    it('resolves and returns correct results when aborted after getting some candidates', async () => {
       const promise = clusterReachability.start();
 
-      // video mesh nodes have shorter timeout of just 1s
-      await clock.tickAsync(1000);
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
+
+      // check the right event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 100,
+        clientMediaIPs: ['somePublicIp'],
+      });
+
+      clusterReachability.abort();
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
+        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
         tcp: {result: 'unreachable'},
         xtls: {result: 'unreachable'},
       });
@@ -233,8 +302,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
-
+      clusterReachability.abort();
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
@@ -262,8 +330,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
-
+      clusterReachability.abort();
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
@@ -293,8 +360,7 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp3', port: 443},
       });
 
-      await clock.tickAsync(3000); // move the clock so that reachability times out
-
+      clusterReachability.abort();
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
@@ -305,22 +371,50 @@ describe('ClusterReachability', () => {
       });
     });
 
-    it('ignores duplicate clientMediaIps', async () => {
+    it('handles new found public IPs and ignores duplicate IPs', async () => {
       const promise = clusterReachability.start();
 
       // generate candidates with duplicate addresses
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
+      // check events emitted: there should be a resultReady and no clientMediaIpsUpdated
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 10,
+        clientMediaIPs: ['somePublicIp1'],
+      });
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+      resetEmittedEvents();
+
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
+      // no new event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
 
+      // check new events: now only clientMediaIpsUpdated event and no resultReady events
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated][0], {
+        protocol: 'udp',
+        clientMediaIPs: ['somePublicIp1', 'somePublicIp2'],
+      });
+      resetEmittedEvents();
+
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
 
+      // no new event was emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+
       // send also a relay candidate so that the reachability check finishes
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
       fakePeerConnection.onicecandidate({