@webex/plugin-meetings 3.0.0-stream-classes.2 → 3.0.0-stream-classes.4

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) {
@@ -214,8 +215,6 @@ export default class TurnDiscovery {
       mediaId: meeting.mediaId,
       meetingId: meeting.id,
       locusMediaRequest: meeting.locusMediaRequest,
-      // @ts-ignore - because of meeting.webex
-      ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
     });
   }
 

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

@@ -1674,6 +1674,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;
@@ -1687,12 +1689,11 @@ 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()
             .resolves({turnServerInfo: {}, turnDiscoverySkippedReason: 'reachability'});
-          
+
           StaticConfig.set({bandwidth: {audio: 1234, video: 5678, startBitrate: 9876}});
 
           // setup things that are expected to be the same across all the tests and are actually irrelevant for these tests
@@ -1768,6 +1769,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
@@ -1855,7 +1857,7 @@ describe('plugin-meetings', () => {
               ],
               clientMediaPreferences: {
                 preferTranscoding: !meeting.isMultistream,
-                ipver: 0
+                ipver: undefined
               },
               respOnlySdp: true,
               usingResource: null,
@@ -1936,7 +1938,7 @@ describe('plugin-meetings', () => {
           // and that it was the only /media request that was sent
           assert.calledOnce(locusMediaRequestStub);
         });
-          
+
         it('addMedia() works correctly when media is enabled with streams to publish', async () => {
           await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
           await simulateRoapOffer();
@@ -2083,7 +2085,7 @@ describe('plugin-meetings', () => {
                 } else {
                   assert.notCalled(locusMediaRequestStub);
                 }
-                
+
                 if (isMultistream) {
                   assert.calledOnceWithExactly(meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream, fakeMicrophoneStream);
                 } else {
@@ -4523,7 +4525,7 @@ describe('plugin-meetings', () => {
               payload: {
                 canProceed: false,
               },
-              options: {showToUser: true, rawError: error, meetingId: meeting.id},
+              options: {rawError: error, meetingId: meeting.id},
             });
           };
 

package/test/unit/spec/meeting/locusMediaRequest.ts

@@ -68,7 +68,6 @@ describe('LocusMediaRequest.send()', () => {
     mediaId: 'mediaId',
     selfUrl: 'fakeMeetingSelfUrl',
     muteOptions: {},
-    ipVersion: IP_VERSION.only_ipv6
   };
 
   const createExpectedLocalMuteBody = (expectedMute:{audioMuted: boolean, videoMuted: boolean}, sequence = undefined) => {
@@ -89,7 +88,7 @@ describe('LocusMediaRequest.send()', () => {
       ],
       clientMediaPreferences: {
         preferTranscoding: true,
-        ipver: 6,
+        ipver: undefined,
       },
     };
 

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

@@ -237,6 +237,29 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.invitee.address, 'sipUrl');
       });
 
+      it('sends uses the locusClusterUrl if available', async () => {
+        const deviceUrl = 'deviceUrl';
+        const correlationId = 'random-uuid';
+        const roapMessage = 'roap-message';
+        const inviteeAddress = 'sipUrl';
+        const locusClusterUrl = 'locusClusterUrl';
+
+        await meetingsRequest.joinMeeting({
+          deviceUrl,
+          correlationId,
+          roapMessage,
+          locusClusterUrl,
+          inviteeAddress,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(
+          requestParams.uri,
+          'https://locusClusterUrl/locus/api/v1/loci/call?alternateRedirect=true'
+        );
+      });
+
       it('adds deviceCapabilities to request when breakouts are supported', async () => {
         await meetingsRequest.joinMeeting({
           breakoutsSupported: true,

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;
@@ -337,7 +336,6 @@ describe('plugin-meetings', () => {
           selfUrl: 'self url',
           sequence: {},
           type: 'LocalMute',
-          ipVersion: 0,
         });
 
         assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
@@ -517,6 +515,26 @@ describe('plugin-meetings', () => {
         assert.isUndefined(parameter.inviteeAddress);
         assert.equal(parameter.meetingNumber, 'meetingNumber');
       });
+
+      it('should pass in the locusClusterUrl from meetingInfo', async () => {
+        const meeting = {
+          meetingInfo: {
+            locusClusterUrl: 'locusClusterUrl',
+          },
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {});
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.locusClusterUrl, 'locusClusterUrl');
+      });
     });
 
     describe('joinMeetingOptions', () => {
@@ -963,5 +981,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/reconnection-manager/index.js

@@ -58,6 +58,9 @@ describe('plugin-meetings', () => {
           updateMediaConnection: sinon.stub(),
         },
         webex: {
+          credentials: {
+            isUnverifiedGuest: false,
+          },
           meetings: {
             getMeetingByType: sinon.stub().returns(true),
             syncMeetings: sinon.stub().resolves({}),
@@ -71,6 +74,24 @@ describe('plugin-meetings', () => {
       };
     });
 
+    it('syncs meetings if it is not an unverified guest', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(rm.webex.meetings.syncMeetings);
+    });
+
+    it('does not sync meetings if it is an unverified guest', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      rm.webex.credentials.isUnverifiedGuest = true;
+
+      await rm.reconnect();
+
+      assert.notCalled(rm.webex.meetings.syncMeetings);
+    });
+
     it('uses correct TURN TLS information on the reconnection', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 

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 },
@@ -73,7 +74,8 @@ describe('TurnDiscovery', () => {
     await testUtils.flushPromises();
 
     assert.calledOnce(mockRoapRequest.sendRoap);
-    assert.calledWith(mockRoapRequest.sendRoap, {
+
+    const expectedSendRoapArgs: any = {
       roapMessage: {
         messageType,
         version: '2',
@@ -83,8 +85,13 @@ describe('TurnDiscovery', () => {
       mediaId: expectedMediaId,
       meetingId: testMeeting.id,
       locusMediaRequest: testMeeting.locusMediaRequest,
-      ipVersion: 0,
-    });
+    };
+
+    if (messageType === 'TURN_DISCOVERY_REQUEST') {
+      expectedSendRoapArgs.ipVersion = 0;
+    }
+    
+    assert.calledWith(mockRoapRequest.sendRoap, expectedSendRoapArgs);
 
     if (messageType === 'TURN_DISCOVERY_REQUEST') {
       // check also that we've applied the media connections from the response