@webex/plugin-meetings 3.0.0-beta.236 → 3.0.0-beta.238

package/src/reachability/index.ts

@@ -7,7 +7,9 @@
 import _ from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY, IP_VERSION} from '../constants';
+import MeetingUtil from '../meeting/util';
+
+import {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY} from '../constants';
 
 import ReachabilityRequest from './request';
 
@@ -71,7 +73,7 @@ export default class Reachability {
     // Fetch clusters and measure latency
     try {
       const {clusters, joinCookie} = await this.reachabilityRequest.getClusters(
-        this.getIpVersion()
+        MeetingUtil.getIpVersion(this.webex)
       );
 
       // Perform Reachability Check
@@ -134,14 +136,6 @@ export default class Reachability {
     return reachable;
   }
 
-  /**
-   * Returns what we know about the IP version of the networks we're connected to.
-   * @returns {IP_VERSION}
-   */
-  getIpVersion(): IP_VERSION {
-    return IP_VERSION.unknown;
-  }
-
   /**
    * Generate peerConnection config settings
    * @param {object} cluster

package/src/reachability/request.ts

@@ -33,7 +33,7 @@ class ReachabilityRequest {
    * @param {IP_VERSION} ipVersion information about current ip network we're on
    * @returns {Promise}
    */
-  getClusters = (ipVersion: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
+  getClusters = (ipVersion?: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
     this.webex
       .request({
         method: HTTP_VERBS.GET,

package/src/roap/index.ts

@@ -7,6 +7,7 @@ import LoggerProxy from '../common/logs/logger-proxy';
 import RoapRequest from './request';
 import TurnDiscovery from './turnDiscovery';
 import Meeting from '../meeting';
+import MeetingUtil from '../meeting/util';
 
 /**
  * Roap options
@@ -201,7 +202,7 @@ export default class Roap extends StatelessWebexPlugin {
           meetingId: meeting.id,
           preferTranscoding: !meeting.isMultistream,
           locusMediaRequest: meeting.locusMediaRequest,
-          ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
+          ipVersion: MeetingUtil.getIpVersion(meeting.webex),
         })
         .then(({locus, mediaConnections}) => {
           if (mediaConnections) {

package/src/roap/turnDiscovery.ts

@@ -8,6 +8,7 @@ import {ROAP} from '../constants';
 
 import RoapRequest from './request';
 import Meeting from '../meeting';
+import MeetingUtil from '../meeting/util';
 
 const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 
@@ -183,7 +184,7 @@ export default class TurnDiscovery {
         meetingId: meeting.id,
         locusMediaRequest: meeting.locusMediaRequest,
         // @ts-ignore - because of meeting.webex
-        ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
+        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
       .then(({mediaConnections}) => {
         if (mediaConnections) {

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

@@ -1649,6 +1649,8 @@ describe('plugin-meetings', () => {
           beforeEach(() => {
             clock = sinon.useFakeTimers();
 
+            sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+
             meeting.deviceUrl = 'deviceUrl';
             meeting.config.deviceType = 'web';
             meeting.isMultistream = isMultistream;
@@ -1662,7 +1664,6 @@ describe('plugin-meetings', () => {
             meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
             meeting.webex.meetings.reachability = {
               isAnyClusterReachable: sinon.stub().resolves(true),
-              getIpVersion: () => IP_VERSION.unknown,
             };
             meeting.roap.doTurnDiscovery = sinon
               .stub()
@@ -1739,6 +1740,7 @@ describe('plugin-meetings', () => {
 
           afterEach(() => {
             clock.restore();
+            sinon.restore();
           });
 
           // helper function that waits until all promises are resolved and any queued up /media requests to Locus are sent out

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

@@ -4,10 +4,9 @@ import Meetings from '@webex/plugin-meetings';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
-import Metrics from '@webex/plugin-meetings/src/metrics/index';
-import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
-import {DISPLAY_HINTS} from '@webex/plugin-meetings/src/constants';
+import {SELF_POLICY, IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import MockWebex from '@webex/test-helper-mock-webex';
+import * as BrowserDetectionModule from '@webex/plugin-meetings/src/common/browser-detection';
 
 describe('plugin-meetings', () => {
   let webex;
@@ -984,5 +983,56 @@ describe('plugin-meetings', () => {
         assert.equal(result, input);
       });
     });
+
+    describe('getIpVersion', () => {
+      let isBrowserStub;
+      beforeEach(() => {
+        isBrowserStub = sinon.stub().returns(false);
+
+        sinon.stub(BrowserDetectionModule, 'default').returns({
+          isBrowser: isBrowserStub,
+        });
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      [
+        {supportsIpV4: undefined, supportsIpV6: undefined, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: undefined, supportsIpV6: true, expectedOutput: IP_VERSION.only_ipv6},
+        {supportsIpV4: undefined, supportsIpV6: false, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: true, supportsIpV6: undefined, expectedOutput: IP_VERSION.only_ipv4},
+        {supportsIpV4: true, supportsIpV6: true, expectedOutput: IP_VERSION.ipv4_and_ipv6},
+        {supportsIpV4: true, supportsIpV6: false, expectedOutput: IP_VERSION.only_ipv4},
+        {supportsIpV4: false, supportsIpV6: undefined, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: false, supportsIpV6: true, expectedOutput: IP_VERSION.only_ipv6},
+        {supportsIpV4: false, supportsIpV6: false, expectedOutput: IP_VERSION.unknown},
+      ].forEach(({supportsIpV4, supportsIpV6, expectedOutput}) => {
+        it(`returns ${expectedOutput} when supportsIpV4=${supportsIpV4} and supportsIpV6=${supportsIpV6}`, () => {
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+            .get(() => supportsIpV4);
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+            .get(() => supportsIpV6);
+
+          assert.equal(MeetingUtil.getIpVersion(webex), expectedOutput);
+        });
+
+        it(`returns undefined when supportsIpV4=${supportsIpV4} and supportsIpV6=${supportsIpV6} and browser is firefox`, () => {
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+            .get(() => supportsIpV4);
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+            .get(() => supportsIpV6);
+
+          isBrowserStub.callsFake((name) => name === 'firefox');
+
+          assert.equal(MeetingUtil.getIpVersion(webex), undefined);
+        });
+      });
+    });
   });
 });

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

@@ -20,6 +20,7 @@ import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
 import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
 import Reachability from '@webex/plugin-meetings/src/reachability';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import testUtils from '../../../utils/testUtils';
 import {
@@ -46,6 +47,8 @@ describe('plugin-meetings', () => {
     debug: () => {},
   };
 
+  let triggerProxyStub;
+
   beforeEach(() => {
     StaticConfig.set({
       bandwidth: {
@@ -57,7 +60,7 @@ describe('plugin-meetings', () => {
       verboseEvents: true,
       enable: false,
     });
-    sinon.stub(TriggerProxy, 'trigger').returns(true);
+    triggerProxyStub = sinon.stub(TriggerProxy, 'trigger').returns(true);
   });
 
   let webex;
@@ -2092,5 +2095,67 @@ describe('plugin-meetings', () => {
         assert.calledWith(webex.meetings.handleLocusEvent, {locus: breakoutLocus, locusUrl: breakoutLocus.url});
       });
     });
+
+    describe('uploading of logs', () => {
+      let metricsSpy;
+      let meeting;
+
+      beforeEach(async () => {
+        webex.meetings.config.autoUploadLogs = true;
+        webex.meetings.loggerRequest.uploadLogs = sinon.stub().resolves();
+
+        sinon.stub(webex.meetings.meetingInfo, 'fetchInfoOptions').resolves({});
+        sinon.stub(webex.meetings.meetingInfo, 'fetchMeetingInfo').resolves({});
+
+        triggerProxyStub.restore();
+
+        metricsSpy = sinon.stub(Metrics, 'sendBehavioralMetric');
+
+        meeting = await webex.meetings.create('test');
+
+        meeting.locusId = 'locus id';
+        meeting.correlationId = 'correlation id';
+        meeting.locusInfo = {
+          fullState: { lastActive: 'last active'},
+          info: { webExMeetingId: 'meeting id'}
+        }
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      })
+
+      it('sends metrics on success', async () => {
+
+        await meeting.uploadLogs();
+
+        await testUtils.flushPromises();
+
+        assert.calledOnceWithExactly(metricsSpy, 'js_sdk_upload_logs_success', {
+          callStart: 'last active',
+          correlationId: 'correlation id',
+          feedbackId: 'correlation id',
+          locusId: 'locus id',
+          meetingId: 'meeting id',
+        });
+      });
+
+      it('sends metrics on failure', async () => {
+        webex.meetings.loggerRequest.uploadLogs.rejects(new Error('fake error'));
+
+        await meeting.uploadLogs();
+
+        await testUtils.flushPromises();
+
+        assert.calledOnceWithExactly(metricsSpy, 'js_sdk_upload_logs_failure', sinon.match({
+          callStart: 'last active',
+          correlationId: 'correlation id',
+          feedbackId: 'correlation id',
+          locusId: 'locus id',
+          meetingId: 'meeting id',
+          reason: 'fake error',
+        }));
+      });
+    });
   });
 });

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

@@ -2,6 +2,8 @@ import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import Reachability, {ICECandidateResult} from '@webex/plugin-meetings/src/reachability/';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+
 import { IP_VERSION } from '@webex/plugin-meetings/src/constants';
 
 describe('isAnyClusterReachable', () => {
@@ -9,6 +11,12 @@ describe('isAnyClusterReachable', () => {
 
   beforeEach(() => {
     webex = new MockWebex();
+
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+  });
+
+  afterEach(() => {
+    sinon.restore();
   });
 
   const checkIsClusterReachable = async (mockStorage: any, expectedValue: boolean) => {
@@ -251,12 +259,4 @@ describe('gatherReachability', () => {
       });
     });
   });
-
-  describe('getIpVersion', () => {
-    it('returns unknown', () => {
-      const reachability = new Reachability(webex);
-
-      assert.equal(reachability.getIpVersion(), IP_VERSION.unknown);
-    })
-  })
 });

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

@@ -6,6 +6,8 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import Roap from '@webex/plugin-meetings/src/roap/';
 import Meeting from '@webex/plugin-meetings/src/meeting';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+
 import { IP_VERSION } from '../../../../src/constants';
 
 describe('Roap', () => {
@@ -62,9 +64,11 @@ describe('Roap', () => {
         setRoapSeq: sinon.stub(),
         config: {experimental: {enableTurnDiscovery: false}},
         locusMediaRequest: {fake: true},
-        webex: { meetings: { reachability: { isAnyClusterReachable: () => true, getIpVersion: () => IP_VERSION.unknown}}},
+        webex: { meetings: { reachability: { isAnyClusterReachable: () => true}}},
       };
 
+      sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+
       sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
       meeting.setRoapSeq.resetHistory();
     });

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

@@ -5,6 +5,7 @@ import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 
 import testUtils from '../../../utils/testUtils';
 import { IP_VERSION } from '../../../../src/constants';
@@ -24,6 +25,7 @@ describe('TurnDiscovery', () => {
     clock = sinon.useFakeTimers();
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
 
     mockRoapRequest = {
       sendRoap: sinon.fake.resolves({mediaConnections: FAKE_MEDIA_CONNECTIONS_FROM_LOCUS}),
@@ -53,7 +55,6 @@ describe('TurnDiscovery', () => {
       updateMediaConnections: sinon.stub(),
       webex: {meetings: {reachability: {
         isAnyClusterReachable: () => Promise.resolve(false),
-        getIpVersion: () => IP_VERSION.unknown,
       }}},
       isMultistream: false,
       locusMediaRequest: { fake: true },