@webex/plugin-meetings 3.1.0 → 3.2.0

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 () => {