@webex/internal-plugin-mercury 3.0.0-beta.41 → 3.0.0-beta.410

package/test/unit/spec/mercury.js

@@ -152,9 +152,8 @@ describe('plugin-mercury', () => {
       });
 
       describe('when `maxRetries` is set', () => {
-        // skipping due to apparent bug with lolex in all browsers but Chrome.
-        skipInBrowser(it)('fails after `maxRetries` attempts', () => {
-          mercury.config.maxRetries = 2;
+
+        const check = () => {
           socketOpenStub.restore();
           socketOpenStub = sinon.stub(Socket.prototype, 'open');
           socketOpenStub.returns(Promise.reject(new ConnectionError()));
@@ -182,12 +181,42 @@ describe('plugin-mercury', () => {
             .then(() => {
               assert.calledThrice(Socket.prototype.open);
               clock.tick(5 * mercury.config.backoffTimeReset);
-
               return assert.isRejected(promise);
             })
             .then(() => {
               assert.calledThrice(Socket.prototype.open);
             });
+        }
+
+        // skipping due to apparent bug with lolex in all browsers but Chrome.
+        // if initial retries is zero and mercury has never connected max retries is used
+        skipInBrowser(it)('fails after `maxRetries` attempts', () => {
+          mercury.config.maxRetries = 2;
+          mercury.config.initialConnectionMaxRetries = 0;
+
+          return check();
+        });
+
+        // initial retries is non-zero so takes precedence over maxRetries when mercury has never connected
+        skipInBrowser(it)('fails after `initialConnectionMaxRetries` attempts', () => {
+          mercury.config.maxRetries = 0;
+          mercury.config.initialConnectionMaxRetries = 2;
+          return check();
+        });
+
+        // initial retries is non-zero so takes precedence over maxRetries when mercury has never connected
+        skipInBrowser(it)('fails after `initialConnectionMaxRetries` attempts', () => {
+          mercury.config.initialConnectionMaxRetries = 2;
+          mercury.config.maxRetries = 5;
+          return check();
+        });
+
+        // when mercury has connected maxRetries is used and the initialConnectionMaxRetries is ignored
+        skipInBrowser(it)('fails after `initialConnectionMaxRetries` attempts', () => {
+          mercury.config.initialConnectionMaxRetries = 5;
+          mercury.config.maxRetries = 2;
+          mercury.hasEverConnected = true;
+          return check();
         });
       });
 
@@ -541,7 +570,10 @@ describe('plugin-mercury', () => {
             // The socket will never be unset (which seems bad)
             assert.isDefined(mercury.socket, 'Mercury socket is not defined');
 
-            return assert.isRejected(promise);
+            return assert.isRejected(promise).then((error) => {
+              // connection did not fail, so no last error
+              assert.isUndefined(mercury.getLastError());
+            });
           });
         });
 
@@ -560,20 +592,53 @@ describe('plugin-mercury', () => {
           return promiseTick(webex.internal.mercury.config.backoffTimeReset).then(() => {
             assert.equal(
               reason.message,
-              'mercury: prevent socket open when backoffCall no longer defined'
+              'Mercury: prevent socket open when backoffCall no longer defined'
             );
           });
         });
+
+        it('sets lastError when retrying', () => {
+          const realError = new Error('FORCED');
+
+          socketOpenStub.restore();
+          socketOpenStub = sinon.stub(Socket.prototype, 'open');
+          socketOpenStub.onCall(0).returns(Promise.reject(realError));
+          const promise = mercury.connect();
+
+          // Wait for the connect call to setup
+          return promiseTick(webex.internal.mercury.config.backoffTimeReset).then(() => {
+            // Calling disconnect will abort the backoffCall, close the socket, and
+            // reject the connect
+            mercury.disconnect();
+
+            return assert.isRejected(promise).then((error) => {
+              const lastError = mercury.getLastError();
+
+              assert.equal(error.message, "Mercury Connection Aborted");
+              assert.isDefined(lastError);
+              assert.equal(lastError, realError);
+            });
+          });
+        });
       });
     });
 
     describe('#_emit()', () => {
-      it('emits Error-safe events', () => {
+      it('emits Error-safe events and log the error with the call parameters', () => {
+        const error = 'error';
+        const event = {data: 'some data'};
         mercury.on('break', () => {
-          throw new Error();
+          throw error;
         });
+        sinon.stub(mercury.logger, 'error');
 
-        return Promise.resolve(mercury._emit('break'));
+        return Promise.resolve(mercury._emit('break', event)).then((res) => {
+          assert.calledWith(mercury.logger.error, 'Mercury: error occurred in event handler', {
+            error,
+            arguments: ['break', event],
+          });
+          return res;
+        });
       });
     });
 
@@ -707,5 +772,18 @@ describe('plugin-mercury', () => {
             .then((wsUrl) => assert.match(wsUrl, /multipleConnections/)));
       });
     });
+
+    describe('ping pong latency event is forwarded', () => {
+      it('should forward ping pong latency event', () => {
+        const spy = sinon.spy();
+
+        mercury.on('ping-pong-latency', spy);
+
+        return mercury.connect().then(() => {
+          assert.calledWith(spy, 0);
+          assert.calledOnce(spy);
+        });
+      });
+    });
   });
 });

package/test/unit/spec/socket.js

@@ -809,6 +809,23 @@ describe('plugin-mercury', () => {
           reason: 'Pong mismatch',
         });
       });
+
+      it('emits ping pong latency correctly', () => {
+        const spy = sinon.spy();
+
+        socket.on('ping-pong-latency', spy);
+
+        socket._ping(123);
+        mockWebSocket.emit('message', {
+          data: JSON.stringify({
+            type: 'pong',
+            id: 123,
+          }),
+        });
+
+        assert.calledWith(spy, 0);
+        assert.calledOnce(spy);
+      });
     });
   });
 });