@webex/plugin-meetings 3.0.0-test.1 → 3.1.0

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

@@ -253,6 +253,19 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleTlsReachability', () => {
+      it('should have _toggleTlsReachability', () => {
+        assert.equal(typeof webex.meetings._toggleTlsReachability, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to do TLS reachability', () => {
+          webex.meetings._toggleTlsReachability(true);
+          assert.equal(webex.meetings.config.experimental.enableTlsReachability, true);
+        });
+      });
+    });
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', async () => {
@@ -412,9 +425,13 @@ describe('plugin-meetings', () => {
           assert.exists(result);
           assert.instanceOf(result, NoiseReductionEffect);
           assert.containsAllKeys(result, ['audioContext', 'isEnabled', 'isReady', 'options']);
+          assert.equal(result.options.authToken, 'fake_token');
           assert.deepEqual(result.options, {
-            authToken: 'fake_token',
             audioContext: {},
+            authToken: 'fake_token',
+            mode: 'WORKLET',
+            env: 'prod',
+            avoidSimd: false,
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
@@ -424,8 +441,9 @@ describe('plugin-meetings', () => {
         it('creates noise reduction effect with custom options passed', async () => {
           const effectOptions = {
             audioContext: {},
-            mode: 'WORKLET',
-            env: 'prod',
+            mode: 'LEGACY',
+            env: 'int',
+            avoidSimd: true,
           };
 
           const result = await webex.meetings.createNoiseReductionEffect(effectOptions);
@@ -595,6 +613,7 @@ describe('plugin-meetings', () => {
           });
           describe('when destroying meeting is needed', () => {
             let destroySpy;
+            let cleanUpSpy;
 
             const meetingCollectionMeetings = {
               stillValidLocusMeeting: {
@@ -625,7 +644,11 @@ describe('plugin-meetings', () => {
                   loci: [{url: 'still-valid-locus-url'}],
                 })
               );
-              MeetingUtil.cleanUp = sinon.stub().returns(Promise.resolve());
+              cleanUpSpy = sinon.stub(MeetingUtil, 'cleanUp').returns(Promise.resolve());
+            });
+
+            afterEach(() => {
+              cleanUpSpy.restore();
             });
 
             it('destroy any meeting that has no active locus url if keepOnlyLocusMeetings is not defined', async () => {
@@ -1205,7 +1228,8 @@ describe('plugin-meetings', () => {
             webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(
               Promise.resolve({
                 body: {
-                  permissionToken: 'PT',
+                  permissionToken:
+                    'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0',
                   meetingJoinUrl: 'meetingJoinUrl',
                 },
               })
@@ -1308,7 +1332,8 @@ describe('plugin-meetings', () => {
             const meeting = await webex.meetings.createMeeting('test destination', 'test type');
 
             const expectedMeetingData = {
-              permissionToken: 'PT',
+              permissionToken:
+                'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0',
               meetingJoinUrl: 'meetingJoinUrl',
               correlationId: meeting.id,
             };
@@ -1324,7 +1349,8 @@ describe('plugin-meetings', () => {
 
           it('accepts injected meeting info', async () => {
             const meetingInfo = {
-              permissionToken: 'PT',
+              permissionToken:
+                'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0',
               meetingJoinUrl: 'meetingJoinUrl',
             };
 
@@ -1356,7 +1382,8 @@ describe('plugin-meetings', () => {
 
           it('accepts injected meeting info with meeting lookup url', async () => {
             const meetingInfo = {
-              permissionToken: 'PT',
+              permissionToken:
+                'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0',
               meetingJoinUrl: 'meetingJoinUrl',
             };
 
@@ -1401,7 +1428,8 @@ describe('plugin-meetings', () => {
                 infoExtraParams
               );
               const expectedMeetingData = {
-                permissionToken: 'PT',
+                permissionToken:
+                  'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0',
                 meetingJoinUrl: 'meetingJoinUrl',
               };
 
@@ -1502,8 +1530,10 @@ describe('plugin-meetings', () => {
               assert.equal(meeting.meetingNumber, 'locusMeetingId');
               assert.equal(meeting.meetingJoinUrl, 'meetingJoinUrl');
               assert.equal(meeting.owner, 'locusOwner');
-              assert.equal(meeting.permissionToken, 'PT');
-
+              assert.equal(
+                meeting.permissionToken,
+                'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0'
+              );
               assert.calledWith(
                 TriggerProxy.trigger,
                 meeting,
@@ -1802,9 +1832,13 @@ describe('plugin-meetings', () => {
       });
     });
     describe('Public Event Triggers', () => {
+      let cleanUpSpy;
       describe('#destroy', () => {
         beforeEach(() => {
-          MeetingUtil.cleanUp = sinon.stub();
+          cleanUpSpy = sinon.stub(MeetingUtil, 'cleanUp');
+        });
+        afterEach(() => {
+          cleanUpSpy.restore();
         });
         it('should have #destroy', () => {
           assert.exists(webex.meetings.destroy);
@@ -1969,6 +2003,59 @@ describe('plugin-meetings', () => {
             'Failed to fetch preferred site from user - no site will be set'
           );
         });
+
+        it('should fall back to fetching the site from the user', async () => {
+          setup({
+            user: {
+              userPreferences: {
+                userPreferencesItems: {
+                  preferredWebExSite: 'site.webex.com',
+                },
+              },
+            },
+          });
+
+          await webex.meetings.fetchUserPreferredWebexSite();
+
+          assert.equal(webex.meetings.preferredWebexSite, 'site.webex.com');
+          assert.notCalled(loggerProxySpy);
+        });
+
+        forEach(
+          [
+            {user: undefined},
+            {user: {userPreferences: {}}},
+            {user: {userPreferences: {userPreferencesItems: {}}}},
+            {user: {userPreferences: {userPreferencesItems: {preferredWebExSite: undefined}}}},
+          ],
+          ({user}) => {
+            it(`should handle invalid user data ${user}`, async () => {
+              setup({user});
+
+              await webex.meetings.fetchUserPreferredWebexSite();
+
+              assert.equal(webex.meetings.preferredWebexSite, '');
+              assert.calledOnceWithExactly(
+                loggerProxySpy,
+                'Failed to fetch preferred site from user - no site will be set'
+              );
+            });
+          }
+        );
+
+        it('should handle a get user failure', async () => {
+          setup();
+
+          webex.internal.user.get.rejects(new Error());
+
+          await webex.meetings.fetchUserPreferredWebexSite();
+
+          assert.equal(webex.meetings.preferredWebexSite, '');
+          assert.calledOnceWithExactly(
+            loggerProxySpy,
+            'Failed to fetch preferred site from user - no site will be set'
+          );
+        });
       });
     });
 
@@ -1986,7 +2073,8 @@ describe('plugin-meetings', () => {
         webex.meetings.meetingInfo.fetchMeetingInfo = sinon.stub().returns(
           Promise.resolve({
             body: {
-              permissionToken: 'PT',
+              permissionToken:
+                'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxMjM0NTYiLCJwZXJtaXNzaW9uIjp7InVzZXJQb2xpY2llcyI6eyJhIjp0cnVlfX19.wkTk0Hp8sUlq2wi2nP4-Ym4Xb7aEUHzyXA1kzk6f0V0',
               meetingJoinUrl: 'meetingJoinUrl',
             },
           })

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

@@ -5,7 +5,6 @@ import 'jsdom-global/register';
 import sinon from 'sinon';
 import Metrics from '@webex/internal-plugin-metrics';
 import MockWebex from '@webex/test-helper-mock-webex';
-import {browserOnly} from '@webex/test-helper-mocha';
 import {assert} from '@webex/test-helper-chai';
 
 import metrics from '@webex/plugin-meetings/src/metrics';
@@ -14,7 +13,7 @@ import metrics from '@webex/plugin-meetings/src/metrics';
  * Meeting can only run in a browser, so we can only send metrics for
  * browser usage.
  */
-browserOnly(describe)('Meeting metrics', () => {
+describe('Meeting metrics', () => {
   let webex, mockSubmitMetric, sandbox;
 
   beforeEach(() => {

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

@@ -969,6 +969,7 @@ describe('MediaRequestManager', () => {
         maxMbps: 3000,
       },
     ]);
+    clock.uninstall()
   });
 
   describe('maxPayloadBitsPerSecond', () => {

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

@@ -6,7 +6,6 @@ import {RemoteMedia} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
-import { NamedMediaGroup } from "@webex/json-multistream";
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;

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

@@ -18,7 +18,6 @@ import testUtils from '../../../utils/testUtils';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import { expect } from 'chai';
-import { NamedMediaGroup } from "@webex/json-multistream";
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;

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

@@ -4,7 +4,7 @@ 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} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -28,9 +28,8 @@ describe('ClusterReachability', () => {
       isVideoMesh: false,
       udp: ['stun:udp1', 'stun:udp2'],
       tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-      xtls: ['xtls1', 'xtls2'],
+      xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
-
   });
 
   afterEach(() => {
@@ -50,8 +49,26 @@ describe('ClusterReachability', () => {
       iceServers: [
         {username: '', credential: '', urls: ['stun:udp1']},
         {username: '', credential: '', urls: ['stun:udp2']},
-        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp1.webex.com?transport=tcp']},
-        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp2.webex.com:5004?transport=tcp']}
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turn:tcp1.webex.com?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turn:tcp2.webex.com:5004?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turns:xtls1.webex.com?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turns:xtls2.webex.com:443?transport=tcp'],
+        },
       ],
       iceCandidatePoolSize: 0,
       iceTransportPolicy: 'all',
@@ -79,7 +96,7 @@ describe('ClusterReachability', () => {
     assert.deepEqual(clusterReachability.getResult(), {
       udp: {result: 'untested'},
       tcp: {result: 'untested'},
-      xtls: {result: 'untested'}
+      xtls: {result: 'untested'},
     });
   });
 
@@ -92,7 +109,7 @@ describe('ClusterReachability', () => {
 
     afterEach(() => {
       clock.restore();
-    })
+    });
 
     it('should initiate the ICE gathering process', async () => {
       const promise = clusterReachability.start();
@@ -107,11 +124,11 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      await clock.tickAsync(3000); // move the clock so that reachability times out
       await promise;
     });
 
-    it('resolves and has correct result as soon as it finds that both udp and tcp is reachable', async () => {
+    it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
       const promise = clusterReachability.start();
 
       await clock.tickAsync(100);
@@ -120,12 +137,17 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
 
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
         tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'untested'}
+        xtls: {result: 'reachable', latencyInMilliseconds: 300},
       });
     });
 
@@ -139,7 +161,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -148,7 +170,7 @@ describe('ClusterReachability', () => {
         isVideoMesh: true,
         udp: ['stun:udp1', 'stun:udp2'],
         tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-        xtls: ['xtls1', 'xtls2'],
+        xtls: ['stun:xtls1.webex.com', 'stun:xtls1.webex.com:443'],
       });
 
       const promise = clusterReachability.start();
@@ -160,7 +182,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -176,7 +198,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -194,7 +216,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -211,15 +233,19 @@ 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
+      await clock.tickAsync(3000); // move the clock so that reachability times out
 
       await promise;
 
       // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
       assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3']},
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3'],
+        },
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -236,7 +262,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
+      await clock.tickAsync(3000); // move the clock so that reachability times out
 
       await promise;
 
@@ -244,7 +270,38 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'reachable', latencyInMilliseconds: 10},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
+      });
+    });
+
+    it('should store latency only for the first tls relay candidate', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp1', port: 443},
+      });
+
+      // generate more candidates
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp2', port: 443},
+      });
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp3', port: 443},
+      });
+
+      await clock.tickAsync(3000); // move the clock so that reachability times out
+
+      await promise;
+
+      // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'reachable', latencyInMilliseconds: 10},
       });
     });
 
@@ -266,13 +323,20 @@ describe('ClusterReachability', () => {
 
       // send also a relay candidate so that the reachability check finishes
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
 
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2']},
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1', 'somePublicIp2'],
+        },
         tcp: {result: 'reachable', latencyInMilliseconds: 40},
-        xtls: {result: 'untested'}
+        xtls: {result: 'reachable', latencyInMilliseconds: 40},
       });
     });
   });