@webex/plugin-meetings 3.1.0-next.2 → 3.1.0-next.20

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

@@ -141,6 +141,272 @@ describe('isAnyPublicClusterReachable', () => {
   });
 });
 
+
+describe('isWebexMediaBackendUnreachable', () => {
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const runCheck = async (mockStorage: any, expectedValue: boolean) => {
+    if (mockStorage) {
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
+    }
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.isWebexMediaBackendUnreachable();
+
+    assert.equal(result, expectedValue);
+  };
+
+  [
+    {
+      title: 'no clusters at all',
+      mockStorage: {},
+      expectedResult: false,
+    },
+    {
+      title: 'clusters without results',
+      mockStorage: {a: {}, b: {}},
+      expectedResult: false,
+    },
+    {
+      title: 'all clusters untested',
+      mockStorage: {
+        a: {udp: 'untested'},
+        b: {udp: 'untested', tcp: 'untested'},
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'one cluster with udp reachable',
+      mockStorage: {x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}},
+      expectedResult: false,
+    },
+    {
+      title: 'one cluster with tcp reachable',
+      mockStorage: {x: {tcp: {result: 'reachable'}}},
+      expectedResult: false,
+    },
+    {
+      title: 'one cluster with xtls reachable',
+      mockStorage: {x: {xtls: {result: 'reachable'}}, y: {xtls: {result: 'unreachable'}}},
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with various protocols reachable',
+      mockStorage: {
+        a: {udp: {result: 'reachable'}, tcp: {result: 'reachable'}},
+        b: {udp: {result: 'unreachable'}, tcp: {result: 'reachable'}},
+        c: {tcp: {result: 'reachable'}},
+        d: {xtls: {result: 'reachable'}},
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: true,
+    },
+    {
+      title: 'multiple clusters with UDP and TCP protocols unreachable, but TLS not tested',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with UDP and TCP protocols unreachable, but TLS missing',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with UDP and TLS protocols unreachable, but TCP not tested',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with UDP and TLS protocols unreachable, but TCP missing',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, some untested',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {udp: {result: 'unreachable'}, tcp: {result: 'untested'}, xtls: {result: 'unreachable'}},
+        c: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}, xtls: {result: 'untested'}},
+      },
+      expectedResult: true,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, except for 1 reachable on udp',
+      mockStorage: {
+        a: {
+          udp: {result: 'reachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, except for 1 reachable on tcp',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, except for 1 reachable on xtls',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'reachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with some missing results',
+      mockStorage: {
+        a: {udp: {result: 'unreachable'}},
+        b: {tcp: {result: 'unreachable'}},
+        c: {xtls: {result: 'unreachable'}},
+        d: {},
+      },
+      expectedResult: true,
+    },
+  ].forEach(({mockStorage, expectedResult, title}) => {
+    it(`returns ${expectedResult} when ${title}`, async () => {
+      await runCheck(mockStorage, expectedResult);
+    });
+  });
+});
+
+
 describe('gatherReachability', () => {
   let webex;
 

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

@@ -2,11 +2,14 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
+import {Defer} from '@webex/common';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
+import ReconnectionNotStartedError from '@webex/plugin-meetings/src/common/errors/reconnection-not-started';
+import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 import { RECONNECTION } from '../../../../src/constants';
 import LoggerProxy from '../../../../src/common/logs/logger-proxy';
 import LoggerConfig from '../../../../src/common/logs/logger-config';
-
 const {assert} = chai;
 
 chai.use(chaiAsPromised);
@@ -14,18 +17,15 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('ReconnectionManager.reconnect', () => {
-    const sandbox = sinon.createSandbox();
     let fakeMediaConnection;
     let fakeMeeting;
     let loggerSpy;
 
-    before(() => {
+    beforeEach(() => {
       LoggerConfig.set({ enable: false });
       LoggerProxy.set();
-      loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
-    });
+      loggerSpy = sinon.spy(LoggerProxy.logger, 'info');
 
-    beforeEach(() => {
       fakeMediaConnection = {
         initiateOffer: sinon.stub().resolves({}),
         reconnect: sinon.stub().resolves({}),
@@ -33,6 +33,7 @@ describe('plugin-meetings', () => {
       fakeMeeting = {
         closePeerConnections: sinon.stub().resolves({}),
         createMediaConnection: sinon.stub().returns(fakeMediaConnection),
+        correlationId: 'correlationId',
         config: {
           reconnection: {
             enabled: true,
@@ -47,6 +48,7 @@ describe('plugin-meetings', () => {
             },
           },
         },
+        locusUrl: 'test/id',
         mediaProperties: {
           unsetPeerConnection: sinon.stub(),
           webrtcMediaConnection: fakeMediaConnection,
@@ -83,11 +85,16 @@ describe('plugin-meetings', () => {
             }
           }
         },
+        trigger: sinon.stub(),
       };
+
+      sinon.stub(TriggerProxy, 'trigger').returns(true);
+      sinon.stub(Metrics, 'sendBehavioralMetric');
     });
 
     afterEach(() => {
-      sandbox.reset();
+      sinon.reset();
+      sinon.restore();
     });
 
     it('calls syncMeetings', async () => {
@@ -223,6 +230,99 @@ describe('plugin-meetings', () => {
         });
       }
     });
+
+    it('sends the right metrics and events when succeeds', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledWith(
+        TriggerProxy.trigger,
+        fakeMeeting,
+        {file: 'reconnection-manager/index', function: 'reconnect'},
+        'meeting:reconnectionSuccess'
+      );
+      assert.calledWithMatch(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.recovered',
+        payload: {
+          recoveredBy: 'new',
+        },
+        options: {
+          meetingId: fakeMeeting.id,
+        },
+      });
+      assert.equal(rm.status, RECONNECTION.STATE.DEFAULT_STATUS);
+    });
+
+    it('sends the right metrics and events when fails', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      sinon.stub(rm, 'executeReconnection').rejects(new Error('fake error'));
+
+      await assert.isRejected(rm.reconnect());
+
+      assert.calledWith(
+        TriggerProxy.trigger,
+        fakeMeeting,
+        {file: 'reconnection-manager/index', function: 'reconnect'},
+        'meeting:reconnectionFailure'
+      );
+      assert.calledWithMatch(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.call.aborted',
+        payload: {
+          errors: [
+            {
+              category: 'expected',
+              errorCode: 2008,
+              fatal: true,
+              name: 'media-engine',
+              shownToUser: false,
+            },
+          ],
+        },
+        options: {
+          meetingId: fakeMeeting.id,
+        },
+      });
+      assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_meeting_reconnect_failures', {
+        correlation_id: fakeMeeting.correlationId,
+        locus_id: 'id',
+        reason: 'fake error',
+        stack: sinon.match.any,
+      });
+      assert.equal(rm.status, RECONNECTION.STATE.DEFAULT_STATUS);
+    });
+
+    it('throws ReconnectionNotStartedError if reconnection is already in progress', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+      const defer = new Defer();
+
+      sinon.stub(rm, 'executeReconnection').returns(defer.promise);
+
+      rm.reconnect();
+
+      try {
+        await rm.reconnect();
+
+        fail("rm.reconnect() should have thrown, but it hasn't");
+      } catch (e) {
+        assert.instanceOf(e, ReconnectionNotStartedError);
+      }
+    });
+
+    it('throws ReconnectionNotStartedError if reconnection is disabled in config', async () => {
+      fakeMeeting.config.reconnection.enabled = false;
+
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      try {
+        await rm.reconnect();
+
+        fail("rm.reconnect() should have thrown, but it hasn't");
+      } catch (e) {
+        assert.instanceOf(e, ReconnectionNotStartedError);
+      }
+    });
   });
 
   /**
@@ -316,29 +416,41 @@ describe('plugin-meetings', () => {
 
     describe('waitForIceReconnect()', () => {
       describe('when ice is marked as not disconnected', () => {
+        let clock;
+
         beforeEach(() => {
+          clock = sinon.useFakeTimers();
           reconnectionManager.iceState.disconnected = false;
         });
 
+        afterEach(() => {
+          clock.restore();
+        });
+
         it('should set the disconnected state to true', () => {
-          reconnectionManager.waitForIceReconnect();
+          const promise = reconnectionManager.waitForIceReconnect();
 
           assert.isTrue(reconnectionManager.iceState.disconnected);
+
+          // we let the timer expire
+          clock.tick(reconnectionManager.iceState.timeoutDuration);
+          assert.isRejected(promise);
         });
 
-        it('should return a promise that rejects after a duration', (done) => {
-          reconnectionManager.iceState.timeoutDuration = 100;
+        it('should return a promise that rejects after a duration', async () => {
+          const promise = reconnectionManager.waitForIceReconnect();
 
-          assert.isRejected(reconnectionManager.waitForIceReconnect());
-          done();
+          // we let the timer expire
+          clock.tick(reconnectionManager.iceState.timeoutDuration);
+          assert.isRejected(promise);
         });
 
-        it('should resolve return a resolved promise when triggered', () => {
+        it('should resolve when ICE is reconnected', async () => {
           const promise = reconnectionManager.waitForIceReconnect();
 
-          reconnectionManager.iceState.resolve();
+          reconnectionManager.iceReconnected();
 
-          assert.isFulfilled(promise);
+          await promise;
         });
       });
 
@@ -359,30 +471,6 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('setStatus()', () => {
-      beforeEach(() => {
-        reconnectionManager.status = RECONNECTION.STATE.DEFAULT_STATUS;
-      });
-
-      it('should correctly change status to in progress', () => {
-        reconnectionManager.setStatus(RECONNECTION.STATE.IN_PROGRESS);
-
-        assert.equal(reconnectionManager.status, RECONNECTION.STATE.IN_PROGRESS);
-      });
-
-      it('should correctly change status to complete', () => {
-        reconnectionManager.setStatus(RECONNECTION.STATE.COMPLETE);
-
-        assert.equal(reconnectionManager.status, RECONNECTION.STATE.COMPLETE);
-      });
-
-      it('should correctly change status to failure', () => {
-        reconnectionManager.setStatus(RECONNECTION.STATE.FAILURE);
-
-        assert.equal(reconnectionManager.status, RECONNECTION.STATE.FAILURE);
-      });
-    });
-
     describe('cleanUp()', () => {
       it('should call reset and keep reference to meeting object', () => {
         const resetSpy = sinon.spy(reconnectionManager, 'reset');

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

@@ -133,20 +133,6 @@ describe('plugin-meetings/roap', () => {
         locusMediaRequest,
       });
 
-      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-        name: 'client.locus.media.request',
-        options: {
-          meetingId: 'meeting-id',
-        },
-      });
-
-      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-        name: 'client.locus.media.response',
-        options: {
-          meetingId: 'meeting-id',
-        },
-      });
-
       const requestParams = locusMediaRequest.send.getCall(0).args[0];
       assert.deepEqual(requestParams, {
         type: 'RoapMessage',
@@ -175,29 +161,6 @@ describe('plugin-meetings/roap', () => {
         },
       });
     });
-
-    it('sends correct client event when fails', async () => {
-      const locusMediaRequest = {send: sinon.stub().rejects({code: 300, message: 'error'})};
-      try {
-        await roapRequest.sendRoap({
-          locusSelfUrl: locusUrl,
-          mediaId: 'mediaId',
-          roapMessage: {
-            seq: 'seq',
-          },
-          meetingId: 'meeting-id',
-          locusMediaRequest,
-        });
-      } catch (err) {
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.locus.media.response',
-          options: {
-            meetingId: 'meeting-id',
-            rawError: {code: 300, message: 'error'},
-          },
-        });
-      }
-    });
   });
 
   it('calls attachReachabilityData when sendRoap', async () => {

package/test/unit/spec/stats-analyzer/index.js

@@ -88,6 +88,7 @@ describe('plugin-meetings', () => {
             trackId: 'RTCMediaStreamTrack_sender_2',
             transportId: 'RTCTransport_0_1',
             type: 'outbound-rtp',
+            requestedBitrate: 10000,
           },
           'audio-send',
           true
@@ -97,6 +98,7 @@ describe('plugin-meetings', () => {
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalBytesSent, 50000);
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalNackCount, 1);
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalPacketsSent, 3600);
+        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.requestedBitrate, 10000);
         assert.strictEqual(
           statsAnalyzer.statsResults['audio-send'].send.retransmittedPacketsSent,
           2
@@ -143,6 +145,7 @@ describe('plugin-meetings', () => {
             trackId: 'RTCMediaStreamTrack_receiver_76',
             transportId: 'RTCTransport_0_1',
             type: 'inbound-rtp',
+            requestedBitrate: 10000,
           },
           'audio-recv-1',
           false
@@ -155,6 +158,7 @@ describe('plugin-meetings', () => {
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.fecPacketsDiscarded, 1);
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.fecPacketsReceived, 1);
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalBytesReceived, 509);
+        assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.requestedBitrate, 10000);
         assert.strictEqual(
           statsAnalyzer.statsResults['audio-recv-1'].recv.headerBytesReceived,
           250
@@ -1202,6 +1206,7 @@ describe('plugin-meetings', () => {
             },
             transmittedKeyFrames: 0,
             requestedKeyFrames: 0,
+            requestedBitrate: 0,
           },
         ]);
         assert.deepEqual(mqeData.audioTransmit[1].streams, [
@@ -1218,6 +1223,7 @@ describe('plugin-meetings', () => {
             },
             transmittedKeyFrames: 0,
             requestedKeyFrames: 0,
+            requestedBitrate: 0,
           },
         ]);
         assert.deepEqual(mqeData.audioReceive[0].streams, [
@@ -1306,6 +1312,7 @@ describe('plugin-meetings', () => {
             transmittedKeyFramesStartup: 0,
             transmittedKeyFramesUnknown: 0,
             transmittedWidth: 0,
+            requestedBitrate: 0,
           },
         ]);
         assert.deepEqual(mqeData.videoTransmit[1].streams, [
@@ -1329,6 +1336,7 @@ describe('plugin-meetings', () => {
             maxNoiseLevel: 0,
             minRegionQp: 0,
             remoteConfigurationChanges: 0,
+            requestedBitrate: 0,
             requestedFrameSize: 0,
             requestedKeyFrames: 0,
             transmittedFrameSize: 0,
@@ -1647,6 +1655,7 @@ describe('plugin-meetings', () => {
             transmittedKeyFramesStartup: 0,
             transmittedKeyFramesUnknown: 0,
             transmittedWidth: 0,
+            requestedBitrate: 0,
           },
           {
             common: {
@@ -1683,6 +1692,7 @@ describe('plugin-meetings', () => {
             transmittedKeyFramesStartup: 0,
             transmittedKeyFramesUnknown: 0,
             transmittedWidth: 0,
+            requestedBitrate: 0,
           },
           {
             common: {
@@ -1719,6 +1729,7 @@ describe('plugin-meetings', () => {
             transmittedKeyFramesStartup: 0,
             transmittedKeyFramesUnknown: 0,
             transmittedWidth: 0,
+            requestedBitrate: 0,
           }
         ]);
       });

package/dist/common/errors/reconnection-in-progress.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["ReconnectInProgress","exports","default","_Error","_inherits2","_super","_createSuper","_classCallCheck2","apply","arguments","_createClass2","_wrapNativeSuper2","Error"],"sources":["reconnection-in-progress.ts"],"sourcesContent":["/**\n *\n *\n * @export\n * @class ReconnectInProgress\n * @extends {Error}\n */\nexport default class ReconnectInProgress extends Error {}\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AANA,IAOqBA,mBAAmB,GAAAC,OAAA,CAAAC,OAAA,0BAAAC,MAAA;EAAA,IAAAC,UAAA,CAAAF,OAAA,EAAAF,mBAAA,EAAAG,MAAA;EAAA,IAAAE,MAAA,GAAAC,YAAA,CAAAN,mBAAA;EAAA,SAAAA,oBAAA;IAAA,IAAAO,gBAAA,CAAAL,OAAA,QAAAF,mBAAA;IAAA,OAAAK,MAAA,CAAAG,KAAA,OAAAC,SAAA;EAAA;EAAA,WAAAC,aAAA,CAAAR,OAAA,EAAAF,mBAAA;AAAA,oBAAAW,iBAAA,CAAAT,OAAA,EAASU,KAAK"}

package/dist/types/common/errors/reconnection-in-progress.d.ts

@@ -1,9 +0,0 @@
-/**
- *
- *
- * @export
- * @class ReconnectInProgress
- * @extends {Error}
- */
-export default class ReconnectInProgress extends Error {
-}

package/src/common/errors/reconnection-in-progress.ts

@@ -1,8 +0,0 @@
-/**
- *
- *
- * @export
- * @class ReconnectInProgress
- * @extends {Error}
- */
-export default class ReconnectInProgress extends Error {}