@webex/plugin-meetings 3.0.0-next.3 → 3.0.0-next.30

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);
@@ -2003,24 +2021,27 @@ describe('plugin-meetings', () => {
           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});
+        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();
+              await webex.meetings.fetchUserPreferredWebexSite();
 
-            assert.equal(webex.meetings.preferredWebexSite, '');
-            assert.calledOnceWithExactly(
-              loggerProxySpy,
-              'Failed to fetch preferred site from user - no site will be set'
-            );
-          });
-        });
+              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();
@@ -2035,7 +2056,6 @@ describe('plugin-meetings', () => {
             'Failed to fetch preferred site from user - no site will be set'
           );
         });
-
       });
     });
 

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},
       });
     });
   });