@webex/internal-plugin-mercury 3.7.0 → 3.8.0-next.2

package/test/unit/spec/mercury.js

@@ -143,9 +143,9 @@ describe('plugin-mercury', () => {
         const envelope = {
           data: {
             featureToggle: {
-              'feature-name': true
-            }
-          }
+              'feature-name': true,
+            },
+          },
         };
 
         assert.isFalse(mercury.connected, 'Mercury is not connected');
@@ -157,7 +157,10 @@ describe('plugin-mercury', () => {
           assert.isFalse(mercury.connecting, 'Mercury is not connecting');
           assert.calledWith(socketOpenStub, sinon.match(/ws:\/\/example.com/), sinon.match.any);
           mercury._emit('event:featureToggle_update', envelope);
-          assert.calledOnceWithExactly(webex.internal.feature.updateFeature, envelope.data.featureToggle);
+          assert.calledOnceWithExactly(
+            webex.internal.feature.updateFeature,
+            envelope.data.featureToggle
+          );
           sinon.restore();
         });
       });
@@ -175,7 +178,6 @@ describe('plugin-mercury', () => {
       });
 
       describe('when `maxRetries` is set', () => {
-
         const check = () => {
           socketOpenStub.restore();
           socketOpenStub = sinon.stub(Socket.prototype, 'open');
@@ -209,7 +211,7 @@ describe('plugin-mercury', () => {
             .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
@@ -504,24 +506,33 @@ describe('plugin-mercury', () => {
     });
 
     describe('#logout()', () => {
-      it('calls disconnect', () => {
+      it('calls disconnect and logs', () => {
+        sinon.stub(mercury.logger, 'info');
         sinon.stub(mercury, 'disconnect');
         mercury.logout();
         assert.called(mercury.disconnect);
+        assert.calledTwice(mercury.logger.info);
+
+        assert.calledWith(mercury.logger.info.getCall(0), 'Mercury: logout() called');
+        assert.isTrue(
+          mercury.logger.info
+            .getCall(1)
+            .args[0].startsWith('Mercury: debug_mercury_logging stack: ')
+        );
       });
 
-      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send code 1050 for logout', () => {
+      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send code 3050 for logout', () => {
         sinon.stub(mercury, 'disconnect');
         mercury.config.beforeLogoutOptionsCloseReason = 'done (permanent)';
         mercury.logout();
-        assert.calledWith(mercury.disconnect, {code: 1050, reason: 'done (permanent)'});
+        assert.calledWith(mercury.disconnect, {code: 3050, reason: 'done (permanent)'});
       });
 
-      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send code 1050 for logout if the reason is different than standard', () => {
+      it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send code 3050 for logout if the reason is different than standard', () => {
         sinon.stub(mercury, 'disconnect');
         mercury.config.beforeLogoutOptionsCloseReason = 'test';
         mercury.logout();
-        assert.calledWith(mercury.disconnect, {code: 1050, reason: 'test'});
+        assert.calledWith(mercury.disconnect, {code: 3050, reason: 'test'});
       });
 
       it('uses the config.beforeLogoutOptionsCloseReason to disconnect and will send undefined for logout if the reason is same as standard', () => {
@@ -554,26 +565,26 @@ describe('plugin-mercury', () => {
             assert.isUndefined(mercury.mockWebSocket, 'Mercury does not have a mockWebSocket');
           }));
 
-          it('disconnects the WebSocket with code 1050', () =>
-            mercury
-              .connect()
-              .then(() => {
-                assert.isTrue(mercury.connected, 'Mercury is connected');
-                assert.isFalse(mercury.connecting, 'Mercury is not connecting');
-                const promise = mercury.disconnect();
-    
-                mockWebSocket.emit('close', {
-                  code: 1050,
-                  reason: 'done (permanent)',
-                });
-    
-                return promise;
-              })
-              .then(() => {
-                assert.isFalse(mercury.connected, 'Mercury is not connected');
-                assert.isFalse(mercury.connecting, 'Mercury is not connecting');
-                assert.isUndefined(mercury.mockWebSocket, 'Mercury does not have a mockWebSocket');
-              }));
+      it('disconnects the WebSocket with code 3050', () =>
+        mercury
+          .connect()
+          .then(() => {
+            assert.isTrue(mercury.connected, 'Mercury is connected');
+            assert.isFalse(mercury.connecting, 'Mercury is not connecting');
+            const promise = mercury.disconnect();
+
+            mockWebSocket.emit('close', {
+              code: 3050,
+              reason: 'done (permanent)',
+            });
+
+            return promise;
+          })
+          .then(() => {
+            assert.isFalse(mercury.connected, 'Mercury is not connected');
+            assert.isFalse(mercury.connecting, 'Mercury is not connecting');
+            assert.isUndefined(mercury.mockWebSocket, 'Mercury does not have a mockWebSocket');
+          }));
 
       it('stops emitting message events', () => {
         const spy = sinon.spy();
@@ -687,7 +698,7 @@ describe('plugin-mercury', () => {
             return assert.isRejected(promise).then((error) => {
               const lastError = mercury.getLastError();
 
-              assert.equal(error.message, "Mercury Connection Aborted");
+              assert.equal(error.message, 'Mercury Connection Aborted');
               assert.isDefined(lastError);
               assert.equal(lastError, realError);
             });
@@ -716,6 +727,21 @@ describe('plugin-mercury', () => {
           return res;
         });
       });
+
+      it('_onmessage without eventType', () => {
+        sinon.spy(mercury, '_getEventHandlers');
+        sinon.spy(mercury, '_emit');
+        const event = {data: {data: {eventType: undefined, mydata: 'some data'}}};
+        mercury.logger.error.restore();
+        sinon.stub(mercury.logger, 'error');
+        return Promise.resolve(mercury._onmessage(event)).then(() => {
+          assert.calledWith(mercury._getEventHandlers, undefined);
+          assert.calledWith(mercury._emit, 'event', event.data);
+          assert.notCalled(mercury.logger.error);
+          mercury._emit.restore();
+          mercury._getEventHandlers.restore();
+        });
+      });
     });
 
     describe('#_applyOverrides()', () => {
@@ -773,6 +799,41 @@ describe('plugin-mercury', () => {
       });
     });
 
+    describe('#_setTimeOffset', () => {
+      it('sets mercuryTimeOffset based on the difference between wsWriteTimestamp and now', () => {
+        const event = {
+          data: {
+            wsWriteTimestamp: Date.now() - 60000,
+          },
+        };
+        assert.isUndefined(mercury.mercuryTimeOffset);
+        mercury._setTimeOffset(event);
+        assert.isDefined(mercury.mercuryTimeOffset);
+        assert.isTrue(mercury.mercuryTimeOffset > 0);
+      });
+      it('handles negative offsets', () => {
+        const event = {
+          data: {
+            wsWriteTimestamp: Date.now() + 60000,
+          },
+        };
+        mercury._setTimeOffset(event);
+        assert.isTrue(mercury.mercuryTimeOffset < 0);
+      });
+      it('handles invalid wsWriteTimestamp', () => {
+        const invalidTimestamps = [null, -1, 'invalid', undefined];
+        invalidTimestamps.forEach((invalidTimestamp) => {
+          const event = {
+            data: {
+              wsWriteTimestamp: invalidTimestamp,
+            },
+          };
+          mercury._setTimeOffset(event);
+          assert.isUndefined(mercury.mercuryTimeOffset);
+        });
+      });
+    });
+
     describe('#_prepareUrl()', () => {
       beforeEach(() => {
         webex.internal.device.webSocketUrl = 'ws://example.com';

package/test/unit/spec/socket.js

@@ -139,6 +139,7 @@ describe('plugin-mercury', () => {
         ));
 
       it('accepts a logLevelToken option', () => {
+        const acknowledgeSpy = sinon.spy(socket, '_acknowledge');
         const promise = socket.open('ws://example.com', {
           forceCloseDelay: mockoptions.forceCloseDelay,
           pingInterval: mockoptions.pingInterval,
@@ -147,6 +148,7 @@ describe('plugin-mercury', () => {
           token: 'mocktoken',
           trackingId: 'mocktrackingid',
           logLevelToken: 'mocklogleveltoken',
+          acknowledgementRequired: true,
         });
 
         mockWebSocket.readyState = 1;
@@ -162,9 +164,83 @@ describe('plugin-mercury', () => {
         });
 
         return promise.then(() => {
+          assert.called(acknowledgeSpy);
           assert.equal(socket.logLevelToken, 'mocklogleveltoken');
         });
       });
+
+      it('accepts acknowledgementRequired option as false and skip acknowledge', () => {
+        const acknowledgeSpy = sinon.spy(socket, '_acknowledge');
+        const promise = socket.open('ws://example.com', {
+          forceCloseDelay: mockoptions.forceCloseDelay,
+          pingInterval: mockoptions.pingInterval,
+          pongTimeout: mockoptions.pongTimeout,
+          logger: console,
+          token: 'mocktoken',
+          trackingId: 'mocktrackingid',
+          logLevelToken: 'mocklogleveltoken',
+          acknowledgementRequired: false,
+        });
+
+        mockWebSocket.readyState = 1;
+        mockWebSocket.emit('open');
+
+        mockWebSocket.emit('message', {
+          data: JSON.stringify({
+            id: uuid.v4(),
+            data: {
+              eventType: 'mercury.buffer_state',
+            },
+          }),
+        });
+
+        return promise.then(() => {
+          assert.notCalled(acknowledgeSpy);
+          assert.equal(socket.logLevelToken, 'mocklogleveltoken');
+        });
+      });
+
+      it('accepts authorizationRequired option as false and skip authorize', () => {
+        const s = new Socket();
+        const authorizeSpy = sinon.spy(socket, '_authorize');
+        socket.open('ws://example.com', {
+          forceCloseDelay: mockoptions.forceCloseDelay,
+          pingInterval: mockoptions.pingInterval,
+          pongTimeout: mockoptions.pongTimeout,
+          logger: console,
+          token: 'mocktoken',
+          trackingId: 'mocktrackingid',
+          logLevelToken: 'mocklogleveltoken',
+          authorizationRequired: false,
+        });
+
+          mockWebSocket.readyState = 1;
+          mockWebSocket.emit('open');
+
+          assert.notCalled(authorizeSpy);
+          assert.called(socket._ping);
+        });
+
+      it('accepts authorizationRequired option as true and calles authorize', () => {
+        const s = new Socket();
+        const authorizeSpy = sinon.spy(socket, '_authorize');
+        socket.open('ws://example.com', {
+          forceCloseDelay: mockoptions.forceCloseDelay,
+          pingInterval: mockoptions.pingInterval,
+          pongTimeout: mockoptions.pongTimeout,
+          logger: console,
+          token: 'mocktoken',
+          trackingId: 'mocktrackingid',
+          logLevelToken: 'mocklogleveltoken',
+          authorizationRequired: true,
+        });
+
+          mockWebSocket.readyState = 1;
+          mockWebSocket.emit('open');
+
+          assert.called(authorizeSpy);
+          assert.called(socket._ping);
+      });
     });
 
     describe('#binaryType', () => {
@@ -452,7 +528,7 @@ describe('plugin-mercury', () => {
         Promise.all([
           assert.isRejected(
             socket.close({code: 1001}),
-            /`options.code` must be 1000 or 1050 or between 3000 and 4999 \(inclusive\)/
+            /`options.code` must be 1000 or between 3000 and 4999 \(inclusive\)/
           ),
           socket.close({code: 1000}),
         ]));
@@ -468,10 +544,10 @@ describe('plugin-mercury', () => {
       it('accepts the logout reason', () =>
             socket
               .close({
-                code: 1050,
+                code: 3050,
                 reason: 'done (permanent)',
               })
-              .then(() => assert.calledWith(mockWebSocket.close, 1050, 'done (permanent)')));
+              .then(() => assert.calledWith(mockWebSocket.close, 3050, 'done (permanent)')));
 
       it('can safely be called called multiple times', () => {
         const p1 = socket.close();
@@ -521,7 +597,7 @@ describe('plugin-mercury', () => {
         });
       });
 
-      it('signals closure if no close frame is received within the specified window, but uses the initial options as 1050 if specified by options call', () => {
+      it('signals closure if no close frame is received within the specified window, but uses the initial options as 3050 if specified by options call', () => {
         const socket = new Socket();
         const promise = socket.open('ws://example.com', mockoptions);
 
@@ -546,21 +622,21 @@ describe('plugin-mercury', () => {
             });
           mockWebSocket.removeAllListeners('close');
 
-          const promise = socket.close({code: 1050, reason: 'done (permanent)'});
+          const promise = socket.close({code: 3050, reason: 'done (permanent)'});
 
           clock.tick(mockoptions.forceCloseDelay);
 
           return promise.then(() => {
             assert.called(spy);
             assert.calledWith(spy, {
-              code: 1050,
+              code: 3050,
               reason: 'done (permanent)',
             });
           });
         });
       });
 
-      it('signals closure if no close frame is received within the specified window, and uses default options as 1000 if the code is not 1050', () => {
+      it('signals closure if no close frame is received within the specified window, and uses default options as 1000 if the code is not 3050', () => {
         const socket = new Socket();
         const promise = socket.open('ws://example.com', mockoptions);
 
@@ -593,7 +669,46 @@ describe('plugin-mercury', () => {
             assert.called(spy);
             assert.calledWith(spy, {
               code: 1000,
-              reason: 'Done (forced)',
+              reason: 'test',
+            });
+          });
+        });
+      });
+
+      it('signals closure if no close frame is received within the specified window, and uses default options as 1000 if the code is not 3050', () => {
+        const socket = new Socket();
+        const promise = socket.open('ws://example.com', mockoptions);
+
+        mockWebSocket.readyState = 1;
+        mockWebSocket.emit('open');
+        mockWebSocket.emit('message', {
+          data: JSON.stringify({
+            id: uuid.v4(),
+            data: {
+              eventType: 'mercury.buffer_state',
+            },
+          }),
+        });
+
+        return promise.then(() => {
+          const spy = sinon.spy();
+
+          socket.on('close', spy);
+          mockWebSocket.close = () =>
+            new Promise(() => {
+              /* eslint no-inline-comments: [0] */
+            });
+          mockWebSocket.removeAllListeners('close');
+
+          const promise = socket.close({code: 1000});
+
+          clock.tick(mockoptions.forceCloseDelay);
+
+          return promise.then(() => {
+            assert.called(spy);
+            assert.calledWith(spy, {
+              code: 1000,
+              reason: 'Done (unknown)',
             });
           });
         });
@@ -705,9 +820,9 @@ describe('plugin-mercury', () => {
         );
       });
 
-      describe('when it receives close code 1050', () => {
-        it(`emits code 1050 for code 1050`, () => {
-          const code = 1050;
+      describe('when it receives close code 3050', () => {
+        it(`emits code 3050 for code 3050`, () => {
+          const code = 3050;
           const reason = 'done (permanent)';
           const spy = sinon.spy();