@webex/plugin-meetings 2.33.2 → 2.35.0

package/test/unit/spec/media/properties.ts

@@ -0,0 +1,305 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MediaProperties from '@webex/plugin-meetings/src/media/properties';
+import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import testUtils from '../../../utils/testUtils';
+import {PC_BAIL_TIMEOUT} from '@webex/plugin-meetings/src/constants';
+import {Defer} from '@webex/common';
+
+describe('MediaProperties', () => {
+  let mediaProperties;
+  let mockPc;
+  let clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+
+    mockPc = {
+      getStats: sinon.stub().resolves([]),
+      addEventListener: sinon.stub(),
+      removeEventListener: sinon.stub(),
+      iceConnectionState: 'connected',
+    };
+
+    sinon.stub(MediaUtil, 'createPeerConnection').returns(mockPc);
+
+    mediaProperties = new MediaProperties();
+  });
+
+  afterEach(() => {
+    clock.restore();
+    sinon.restore();
+  });
+  describe('waitForIceConnectedState', () => {
+    it('resolves immediately if ice state is connected', async () => {
+      mockPc.iceConnectionState = 'connected';
+
+      await mediaProperties.waitForIceConnectedState();
+    });
+    it('resolves immediately if ice state is completed', async () => {
+      mockPc.iceConnectionState = 'completed';
+
+      await mediaProperties.waitForIceConnectedState();
+    });
+    it('rejects after timeout if ice state does not reach connected/completed', async () => {
+      mockPc.iceConnectionState = 'connecting';
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaProperties
+        .waitForIceConnectedState()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      await clock.tickAsync(PC_BAIL_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      // check that listener was registered and removed
+      assert.calledOnce(mockPc.addEventListener);
+      assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
+      const listener = mockPc.addEventListener.getCall(0).args[1];
+
+      assert.calledOnce(mockPc.removeEventListener);
+      assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
+    });
+
+    ['connected', 'completed'].forEach((successIceState) =>
+      it(`resolves when ice state reaches ${successIceState}`, async () => {
+        mockPc.iceConnectionState = 'connecting';
+
+        const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+        let promiseResolved = false;
+        let promiseRejected = false;
+
+        mediaProperties
+          .waitForIceConnectedState()
+          .then(() => {
+            promiseResolved = true;
+          })
+          .catch(() => {
+            promiseRejected = true;
+          });
+
+        assert.equal(promiseResolved, false);
+        assert.equal(promiseRejected, false);
+
+        // check the right listener was registered
+        assert.calledOnce(mockPc.addEventListener);
+        assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
+        const listener = mockPc.addEventListener.getCall(0).args[1];
+
+        // call the listener and pretend we are now connected
+        mockPc.iceConnectionState = successIceState;
+        listener();
+        await testUtils.flushPromises();
+
+        assert.equal(promiseResolved, true);
+        assert.equal(promiseRejected, false);
+
+        // check that listener was removed
+        assert.calledOnce(mockPc.removeEventListener);
+        assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
+
+        assert.calledOnce(clearTimeoutSpy);
+      })
+    );
+  });
+
+  describe('getCurrentConnectionType', () => {
+    it('calls waitForIceConnectedState', async () => {
+      const spy = sinon.stub(mediaProperties, 'waitForIceConnectedState');
+
+      await mediaProperties.getCurrentConnectionType();
+
+      assert.calledOnce(spy);
+    });
+    it('calls getStats() only after waitForIceConnectedState resolves', async () => {
+      const waitForIceConnectedStateResult = new Defer();
+
+      const waitForIceConnectedStateStub = sinon
+        .stub(mediaProperties, 'waitForIceConnectedState')
+        .returns(waitForIceConnectedStateResult.promise);
+
+      const result = mediaProperties.getCurrentConnectionType();
+
+      await testUtils.flushPromises();
+
+      assert.called(waitForIceConnectedStateStub);
+      assert.notCalled(mockPc.getStats);
+
+      waitForIceConnectedStateResult.resolve();
+      await testUtils.flushPromises();
+
+      assert.called(mockPc.getStats);
+      await result;
+    });
+    it('rejects if waitForIceConnectedState rejects', async () => {
+      const waitForIceConnectedStateResult = new Defer();
+
+      const waitForIceConnectedStateStub = sinon
+        .stub(mediaProperties, 'waitForIceConnectedState')
+        .returns(waitForIceConnectedStateResult.promise);
+
+      const result = mediaProperties.getCurrentConnectionType();
+
+      await testUtils.flushPromises();
+
+      assert.called(waitForIceConnectedStateStub);
+
+      waitForIceConnectedStateResult.reject(new Error('fake error'));
+      await testUtils.flushPromises();
+
+      assert.notCalled(mockPc.getStats);
+
+      await assert.isRejected(result);
+    });
+    it('returns "unknown" if getStats() fails', async () => {
+      mockPc.getStats.rejects(new Error());
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "unknown" if getStats() returns no candidate pairs', async () => {
+      mockPc.getStats.resolves([{type: 'something', id: '1234'}]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
+      mockPc.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
+      mockPc.getStats.resolves([
+        {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
+      mockPc.getStats.resolves([
+        {
+          type: 'candidate-pair',
+          id: 'some candidate pair id',
+          state: 'succeeded',
+          localCandidateId: 'local candidate id',
+        },
+        {type: 'local-candidate', id: 'some other candidate id', protocol: 'tcp'},
+        {type: 'local-candidate', id: 'local candidate id', protocol: 'udp'},
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'UDP');
+    });
+
+    it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
+      mockPc.getStats.resolves([
+        {
+          type: 'candidate-pair',
+          id: 'some candidate pair id',
+          state: 'succeeded',
+          localCandidateId: 'some candidate id',
+        },
+        {type: 'local-candidate', id: 'some other candidate id', protocol: 'udp'},
+        {type: 'local-candidate', id: 'some candidate id', protocol: 'tcp'},
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'TCP');
+    });
+
+    [
+      {relayProtocol: 'tls', expectedConnectionType: 'TURN-TLS'},
+      {relayProtocol: 'tcp', expectedConnectionType: 'TURN-TCP'},
+      {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
+    ].forEach(({relayProtocol, expectedConnectionType}) =>
+      it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
+        mockPc.getStats.resolves([
+          {
+            type: 'candidate-pair',
+            id: 'some candidate pair id',
+            state: 'succeeded',
+            localCandidateId: 'selected candidate id',
+          },
+          {
+            type: 'candidate-pair',
+            id: 'some other candidate pair id',
+            state: 'failed',
+            localCandidateId: 'some other candidate id 1',
+          },
+          {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
+          {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
+          {
+            type: 'local-candidate',
+            id: 'selected candidate id',
+            protocol: 'udp',
+            relayProtocol,
+          },
+        ]);
+
+        const connectionType = await mediaProperties.getCurrentConnectionType();
+        assert.equal(connectionType, expectedConnectionType);
+      })
+    );
+
+    it('returns connection type of the first successful candidate pair', async () => {
+      // in real life this will never happen and all active candidate pairs will have same transport,
+      // but here we're simulating a situation where they have different transports and just checking
+      // that the code still works and just returns the first one
+      mockPc.getStats.resolves([
+        {
+          type: 'inbound-rtp',
+          id: 'whatever',
+        },
+        {
+          type: 'candidate-pair',
+          id: 'some candidate pair id',
+          state: 'succeeded',
+          localCandidateId: '1st selected candidate id',
+        },
+        {
+          type: 'candidate-pair',
+          id: 'some other candidate pair id',
+          state: 'succeeded',
+          localCandidateId: '2nd selected candidate id',
+        },
+        {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
+        {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
+        {
+          type: 'local-candidate',
+          id: '1st selected candidate id',
+          protocol: 'udp',
+          relayProtocol: 'tls',
+        },
+        {
+          type: 'local-candidate',
+          id: '2nd selected candidate id',
+          protocol: 'udp',
+          relayProtocol: 'tcp',
+        },
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'TURN-TLS');
+    });
+  });
+});

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

@@ -42,6 +42,7 @@ import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detectio
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import {trigger, eventType} from '@webex/plugin-meetings/src/metrics/config';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+import {IceGatheringFailed} from '@webex/plugin-meetings/src/common/errors/webex-errors';
 
 import locus from '../fixture/locus';
 import {
@@ -910,6 +911,8 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           meeting.mediaProperties.setMediaDirection = sinon.stub().returns(true);
+          meeting.mediaProperties.waitForIceConnectedState = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
           Media.attachMedia = sinon.stub().returns(Promise.resolve([test1, test2]));
@@ -920,7 +923,7 @@ describe('plugin-meetings', () => {
             meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
             resolve();
           }));
-          meeting.roap.doTurnDiscovery = sinon.stub().resolves();
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: {}, turnDiscoverySkippedReason: undefined});
           PeerConnectionManager.setContentSlides = sinon.stub().returns(true);
         });
 
@@ -961,6 +964,39 @@ describe('plugin-meetings', () => {
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
             assert.isNull(meeting.statsAnalyzer);
+            assert(Metrics.sendBehavioralMetric.calledOnce);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: err.message,
+                stack: err.stack,
+                code: err.code,
+                turnDiscoverySkippedReason: undefined,
+                turnServerUsed: true
+              }
+            );
+          });
+        });
+
+        it('checks metrics called with skipped reason config', async () => {
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'});
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia().catch((err) => {
+            assert.exists(err);
+            assert(Metrics.sendBehavioralMetric.calledOnce);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: err.message,
+                stack: err.stack,
+                turnDiscoverySkippedReason: 'config',
+                turnServerUsed: false
+              }
+            );
           });
         });
 
@@ -970,6 +1006,18 @@ describe('plugin-meetings', () => {
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
             assert.isNull(meeting.mediaProperties.peerConnection);
+            assert(Metrics.sendBehavioralMetric.calledOnce);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: err.message,
+                stack: err.stack,
+                turnDiscoverySkippedReason: undefined,
+                turnServerUsed: true
+              }
+            );
           });
         });
 
@@ -1035,6 +1083,8 @@ describe('plugin-meetings', () => {
         });
 
         it('should attach the media and return promise', async () => {
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+
           meeting.meetingState = 'ACTIVE';
           MediaUtil.createPeerConnection.resetHistory();
           const media = meeting.addMedia({
@@ -1065,10 +1115,14 @@ describe('plugin-meetings', () => {
           meeting.meetingState = 'ACTIVE';
           MediaUtil.createPeerConnection.resetHistory();
 
+
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({
-            url: FAKE_TURN_URL,
-            username: FAKE_TURN_USER,
-            password: FAKE_TURN_PASSWORD
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD
+            },
+            turnServerSkippedReason: undefined
           });
           const media = meeting.addMedia({
             mediaSettings: {}
@@ -1087,6 +1141,7 @@ describe('plugin-meetings', () => {
         });
 
         it('should attach the media and return promise', async () => {
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
           meeting.meetingState = 'ACTIVE';
           meeting.mediaProperties.peerConnection.connectionState = 'DISCONNECTED';
           const media = meeting.addMedia({
@@ -1099,6 +1154,41 @@ describe('plugin-meetings', () => {
           });
         });
 
+        it('should reject if waitForIceConnectedState() rejects', async () => {
+          meeting.meetingState = 'ACTIVE';
+          meeting.mediaProperties.waitForIceConnectedState.rejects(new Error('fake error'));
+
+          let errorThrown = false;
+
+          await meeting.addMedia({
+            mediaSettings: {}
+          })
+            .catch((error) => {
+              assert.equal(error.code, IceGatheringFailed.CODE);
+              errorThrown = true;
+            });
+
+          assert.isTrue(errorThrown);
+        });
+
+        it('should send ADD_MEDIA_SUCCESS metrics', async () => {
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {}
+          });
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              connectionType: 'udp'
+            }
+          );
+        });
+
         describe('handles StatsAnalyzer events', () => {
           let prevConfigValue;
           let statsAnalyzerStub;

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

@@ -117,14 +117,15 @@ describe('TurnDiscovery', () => {
       // check that we've sent OK
       await checkRoapMessageSent('OK', 0);
 
-      const turnInfo = await result;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await result;
 
-      assert.deepEqual(turnInfo, {
+      assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD
       });
 
+      assert.isUndefined(turnDiscoverySkippedReason);
     });
 
     it('sends TURN_DISCOVERY_REQUEST with empty mediaId when isReconnecting is true', async () => {
@@ -152,13 +153,14 @@ describe('TurnDiscovery', () => {
       // check that we've sent OK
       await checkRoapMessageSent('OK', 0);
 
-      const turnInfo = await result;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await result;
 
-      assert.deepEqual(turnInfo, {
+      assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD
       });
+      assert.isUndefined(turnDiscoverySkippedReason);
     });
 
     it('ignores any extra, unexpected headers in the response', async () => {
@@ -187,13 +189,13 @@ describe('TurnDiscovery', () => {
       // check that we've sent OK and still parsed the headers we care about
       await checkRoapMessageSent('OK', 0);
 
-      const turnInfo = await result;
-
-      assert.deepEqual(turnInfo, {
+      const {turnServerInfo, turnDiscoverySkippedReason} = await result;
+      assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD
       });
+      assert.isUndefined(turnDiscoverySkippedReason);
     });
 
     it('resolves with undefined if turn discovery feature is disabled in config', async () => {
@@ -203,7 +205,10 @@ describe('TurnDiscovery', () => {
 
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
-      assert.isUndefined(result);
+      const {turnServerInfo, turnDiscoverySkippedReason} = result;
+
+      assert.isUndefined(turnServerInfo);
+      assert.equal(turnDiscoverySkippedReason, 'config');
       assert.notCalled(mockRoapRequest.sendRoap);
       assert.notCalled(Metrics.sendBehavioralMetric);
 
@@ -218,7 +223,10 @@ describe('TurnDiscovery', () => {
 
       const result = await td.doTurnDiscovery(testMeeting, false);
 
-      assert.isUndefined(result);
+      const {turnServerInfo, turnDiscoverySkippedReason} = result;
+
+      assert.isUndefined(turnServerInfo);
+      assert.isUndefined(turnDiscoverySkippedReason);
       checkFailureMetricsSent();
     });
 
@@ -227,7 +235,10 @@ describe('TurnDiscovery', () => {
       testMeeting.webex.meetings.reachability.isAnyClusterReachable = () => true;
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
-      assert.isUndefined(result);
+      const {turnServerInfo, turnDiscoverySkippedReason} = result;
+
+      assert.isUndefined(turnServerInfo);
+      assert.equal(turnDiscoverySkippedReason, 'reachability');
       assert.notCalled(mockRoapRequest.sendRoap);
       assert.notCalled(Metrics.sendBehavioralMetric);
       testMeeting.webex.meetings.reachability.isAnyClusterReachable = prev;
@@ -242,9 +253,10 @@ describe('TurnDiscovery', () => {
       await clock.tickAsync(10 * 1000);
       await testUtils.flushPromises();
 
-      const turnInfo = await promise;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await promise;
 
-      assert.isUndefined(turnInfo);
+      assert.isUndefined(turnServerInfo);
+      assert.isUndefined(turnDiscoverySkippedReason);
       checkFailureMetricsSent();
     });
 
@@ -260,9 +272,10 @@ describe('TurnDiscovery', () => {
         ]
       });
       await testUtils.flushPromises();
-      const turnInfo = await turnDiscoveryPromise;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
-      assert.isUndefined(turnInfo);
+      assert.isUndefined(turnServerInfo);
+      assert.isUndefined(turnDiscoverySkippedReason);
       checkFailureMetricsSent();
     });
 
@@ -274,9 +287,10 @@ describe('TurnDiscovery', () => {
       td.handleTurnDiscoveryResponse({});
 
       await testUtils.flushPromises();
-      const turnInfo = await turnDiscoveryPromise;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
-      assert.isUndefined(turnInfo);
+      assert.isUndefined(turnServerInfo);
+      assert.isUndefined(turnDiscoverySkippedReason);
       checkFailureMetricsSent();
     });
 
@@ -288,9 +302,10 @@ describe('TurnDiscovery', () => {
       td.handleTurnDiscoveryResponse({headers: []});
 
       await testUtils.flushPromises();
-      const turnInfo = await turnDiscoveryPromise;
+      const {turnServerInfo, turnDiscoverySkippedReason}= await turnDiscoveryPromise;
 
-      assert.isUndefined(turnInfo);
+      assert.isUndefined(turnServerInfo);
+      assert.isUndefined(turnDiscoverySkippedReason);
       checkFailureMetricsSent();
     });
 
@@ -321,9 +336,10 @@ describe('TurnDiscovery', () => {
       // check that we've sent OK
       await checkRoapMessageSent('OK', 0);
 
-      const turnInfo = await turnDiscoveryPromise;
+      const {turnServerInfo, turnDiscoverySkippedReason} = await turnDiscoveryPromise;
 
-      assert.isUndefined(turnInfo);
+      assert.isUndefined(turnServerInfo);
+      assert.isUndefined(turnDiscoverySkippedReason);
       checkFailureMetricsSent();
     });
   });