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

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

@@ -412,9 +412,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 +428,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 +2008,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 +2043,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/request.js

@@ -4,6 +4,7 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+import {NewMetrics} from '@webex/internal-plugin-metrics';
 
 
 describe('plugin-meetings/reachability', () => {
@@ -14,6 +15,7 @@ describe('plugin-meetings/reachability', () => {
     webex = new MockWebex({
       children: {
         meetings: Meetings,
+        newMetrics: NewMetrics
       },
     });
 
@@ -22,19 +24,25 @@ describe('plugin-meetings/reachability', () => {
       regionCode: 'WEST-COAST',
     };
 
-    webex.internal = {
-      services: {
-        get: sinon.mock().returns('locusUrl'),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
-      },
+    webex.internal.services = {
+      get: sinon.mock().returns('locusUrl'),
+      waitForCatalog: sinon.mock().returns(Promise.resolve({})),
     };
 
-
     reachabilityRequest = new ReachabilityRequest(webex);
 
   });
 
   describe('#getClusters', () => {
+
+    beforeEach(() => {
+      sinon.spy(webex.internal.newMetrics.callDiagnosticLatencies, 'measureLatency');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
     it('sends a GET request with the correct params', async () => {
       webex.request = sinon.mock().returns(Promise.resolve({
         body: {
@@ -49,7 +57,6 @@ describe('plugin-meetings/reachability', () => {
       }));
 
       const res = await reachabilityRequest.getClusters(IP_VERSION.only_ipv4);
-
       const requestParams = webex.request.getCall(0).args[0];
 
       assert.equal(requestParams.method, 'GET');
@@ -63,6 +70,7 @@ describe('plugin-meetings/reachability', () => {
       });
       assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
       assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+      assert.calledOnceWithExactly(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency, sinon.match.func, 'internal.get.cluster.time');
     });
   });
 });

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

@@ -144,6 +144,34 @@ describe('plugin-meetings', () => {
       });
     });
 
+    // this can happen when we land on a video mesh node
+    it('does not use TURN server if TURN url is an empty string', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      fakeMeeting.roap.doTurnDiscovery.resolves({
+        turnServerInfo: {
+          url: '',
+          username: 'whatever',
+          password: 'whatever',
+        },
+        turnDiscoverySkippedReason: undefined,
+      });
+
+      await rm.reconnect();
+
+      assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
+      assert.calledWith(fakeMeeting.roap.doTurnDiscovery, fakeMeeting, true, true);
+      assert.calledOnce(fakeMediaConnection.reconnect);
+      assert.calledWith(fakeMediaConnection.reconnect, []);
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: rm.meeting.id,
+        },
+      });
+    });
+
     it('does not clear previous requests and re-request media for non-multistream meetings', async () => {
       fakeMeeting.isMultistream = false;
       const rm = new ReconnectionManager(fakeMeeting);

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

@@ -13,15 +13,23 @@ import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import { IP_VERSION } from '../../../../src/constants';
 
 describe('Roap', () => {
+  let webex;
+
+  const RESULT = {something: 'some value'};
+  const meeting = {id: 'some meeting id'} as Meeting;
+
+  beforeEach(() => {
+    webex = new MockWebex({});
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
   describe('doTurnDiscovery', () => {
     [false, true].forEach(function (isReconnecting) {
       [false, true, undefined].forEach(function (isForced) {
         it(`calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments when isReconnecting = ${isReconnecting} and isForced = ${isForced}`, async () => {
-          const webex = new MockWebex({});
-
-          const RESULT = {something: 'some value'};
-          const meeting = {id: 'some meeting id'} as Meeting;
-
           const doTurnDiscoveryStub = sinon
             .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
             .resolves(RESULT);
@@ -32,11 +40,58 @@ describe('Roap', () => {
 
           assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
           assert.deepEqual(result, RESULT);
+        });
+      });
+    });
+
+    describe('generateTurnDiscoveryRequestMessage', () => {
+      [false, true].forEach(function (isForced) {
+        it(`calls this.turnDiscovery.generateTurnDiscoveryRequestMessage with isForced=${isForced}`, async () => {
+          const generateTurnDiscoveryRequestMessageStub = sinon
+            .stub(TurnDiscovery.prototype, 'generateTurnDiscoveryRequestMessage')
+            .resolves(RESULT);
+
+          const roap = new Roap({}, {parent: webex});
 
-          sinon.restore();
+          const result = await roap.generateTurnDiscoveryRequestMessage(meeting, isForced);
+
+          assert.calledOnceWithExactly(generateTurnDiscoveryRequestMessageStub, meeting, isForced);
+          assert.deepEqual(result, RESULT);
         });
       });
     });
+
+    describe('handleTurnDiscoveryHttpResponse', () => {
+      it('calls this.turnDiscovery.handleTurnDiscoveryHttpResponse', async () => {
+        const handleTurnDiscoveryHttpResponseStub = sinon
+          .stub(TurnDiscovery.prototype, 'handleTurnDiscoveryHttpResponse')
+          .resolves(RESULT);
+
+        const httpReponse = {some: 'http response'};
+
+        const roap = new Roap({}, {parent: webex});
+
+        const result = await roap.handleTurnDiscoveryHttpResponse(meeting, httpReponse);
+
+        assert.calledOnceWithExactly(handleTurnDiscoveryHttpResponseStub, meeting, httpReponse);
+        assert.deepEqual(result, RESULT);
+      });
+    });
+
+    describe('abortTurnDiscovery', () => {
+      it('calls this.turnDiscovery.abort', async () => {
+        const abortStub = sinon
+          .stub(TurnDiscovery.prototype, 'abort')
+          .returns(RESULT);
+
+        const roap = new Roap({}, {parent: webex});
+
+        const result = await roap.abortTurnDiscovery();
+
+        assert.calledOnceWithExactly(abortStub);
+        assert.deepEqual(result, RESULT);
+      });
+    });
   });
 
   describe('sendRoapMediaRequest', () => {