@webex/internal-plugin-mercury 3.11.0 → 3.12.0-auth-prejoin-fetch.1

package/src/socket/constants.js

@@ -0,0 +1,6 @@
+export const SOCKET_READY_STATE = Object.freeze({
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3,
+});

package/src/socket/socket-base.js

@@ -17,6 +17,7 @@ import {
   UnknownResponse,
   // NotFound
 } from '../errors';
+import {SOCKET_READY_STATE} from './constants';
 
 const sockets = new WeakMap();
 
@@ -33,6 +34,8 @@ export default class Socket extends EventEmitter {
     this._domain = 'unknown-domain';
     this.onmessage = this.onmessage.bind(this);
     this.onclose = this.onclose.bind(this);
+    // Increase max listeners to avoid memory leak warning in tests
+    this.setMaxListeners(10);
   }
 
   /**
@@ -114,7 +117,10 @@ export default class Socket extends EventEmitter {
       // logger is defined once open is called
       this.logger.info(`socket,${this._domain}: closing`);
 
-      if (socket.readyState === 2 || socket.readyState === 3) {
+      if (
+        socket.readyState === SOCKET_READY_STATE.CLOSING ||
+        socket.readyState === SOCKET_READY_STATE.CLOSED
+      ) {
         this.logger.info(`socket,${this._domain}: already closed`);
         resolve();
 
@@ -161,7 +167,27 @@ export default class Socket extends EventEmitter {
         resolve(event);
       };
 
-      socket.close(options.code, options.reason);
+      // If socket is still connecting, manually trigger close handler with desired code
+      // because calling close() on a CONNECTING socket may not preserve custom codes
+      if (socket.readyState === SOCKET_READY_STATE.CONNECTING) {
+        this.logger.info(
+          `socket,${this._domain}: socket still connecting, triggering close manually`
+        );
+        clearTimeout(closeTimer);
+        const closeEvent = {code: options.code, reason: options.reason};
+        this.onclose(closeEvent);
+        resolve(closeEvent);
+        try {
+          socket.close(options.code, options.reason);
+        } catch (error) {
+          this.logger.info(
+            `socket,${this._domain}: error while closing CONNECTING socket, likely due to browser incompatibility with custom close codes`,
+            error
+          );
+        }
+      } else {
+        socket.close(options.code, options.reason);
+      }
     });
   }
 
@@ -328,7 +354,7 @@ export default class Socket extends EventEmitter {
    */
   send(data) {
     return new Promise((resolve, reject) => {
-      if (this.readyState !== 1) {
+      if (this.readyState !== SOCKET_READY_STATE.OPEN) {
         return reject(new Error('INVALID_STATE_ERROR'));
       }
 
@@ -358,9 +384,20 @@ export default class Socket extends EventEmitter {
       return Promise.reject(new Error('`event.data.id` is required'));
     }
 
+    // Don't try to acknowledge if socket is not in open state
+    if (this.readyState !== SOCKET_READY_STATE.OPEN) {
+      return Promise.resolve(); // Silently ignore acknowledgment for closed sockets
+    }
+
     return this.send({
       messageId: event.data.id,
       type: 'ack',
+    }).catch((error) => {
+      // Gracefully handle send errors (like INVALID_STATE_ERROR) to prevent test issues
+      if (error.message === 'INVALID_STATE_ERROR') {
+        return Promise.resolve(); // Socket was closed, ignore the acknowledgment
+      }
+      throw error; // Re-throw other errors
     });
   }
 

package/test/unit/spec/mercury-events.js

@@ -38,14 +38,31 @@ describe('plugin-mercury', () => {
         },
         timestamp: Date.now(),
         trackingId: `suffix_${uuid.v4()}_${Date.now()}`,
+        sessionId: 'mercury-default-session',
       };
 
       beforeEach(() => {
         clock = FakeTimers.install({now: Date.now()});
       });
 
-      afterEach(() => {
+      afterEach(async () => {
         clock.uninstall();
+        // Clean up mercury socket and mockWebSocket
+        if (mercury && mercury.socket) {
+          try {
+            await mercury.socket.close();
+          } catch (e) {}
+        }
+        if (mockWebSocket && typeof mockWebSocket.close === 'function') {
+          mockWebSocket.close();
+        }
+        // Restore stubs
+        if (Socket.getWebSocketConstructor.restore) {
+          Socket.getWebSocketConstructor.restore();
+        }
+        if (socketOpenStub && socketOpenStub.restore) {
+          socketOpenStub.restore();
+        }
       });
 
       beforeEach(() => {
@@ -76,6 +93,7 @@ describe('plugin-mercury', () => {
         });
 
         mercury = webex.internal.mercury;
+        mercury.defaultSessionId = 'mercury-default-session';
       });
 
       afterEach(() => {
@@ -249,8 +267,14 @@ describe('plugin-mercury', () => {
           },
           {
             code: 4000,
+            reason: 'Replaced',
             action: 'replace',
           },
+          {
+            code: 4000,
+            reason: 'Unexpected close',
+            action: 'reconnect',
+          },
           {
             action: 'close',
           },
@@ -274,6 +298,8 @@ describe('plugin-mercury', () => {
                 mercury._reconnect.restore();
               }
 
+              let expectedReconnectUrl;
+
               sinon.spy(mercury, 'connect');
 
               const offlineSpy = sinon.spy();
@@ -295,13 +321,19 @@ describe('plugin-mercury', () => {
                   // Make sure mercury.connect has a call count of zero
                   mercury.connect.resetHistory();
 
+                  // Reconnection re-derives from the resolved URL
+                  // captured in _prepareAndOpenSocket, not the socket's actual
+                  // (possibly changed by interceptors) url.
+                  expectedReconnectUrl =
+                    mercury.sessionWebSocketUrls.get('mercury-default-session');
+
                   mockWebSocket.emit('close', {code, reason});
 
                   return promiseTick(1);
                 })
                 .then(() => {
                   assert.called(offlineSpy);
-                  assert.calledWith(offlineSpy, {code, reason});
+                  assert.calledWith(offlineSpy, {code, reason, sessionId: 'mercury-default-session'});
                   switch (action) {
                     case 'close':
                       assert.called(permanentSpy);
@@ -324,7 +356,7 @@ describe('plugin-mercury', () => {
                   assert.isFalse(mercury.connected, 'Mercury is not connected');
                   if (action === 'reconnect') {
                     assert.called(mercury.connect);
-                    assert.calledWith(mercury.connect, mockWebSocket.url);
+                    assert.calledWith(mercury.connect, expectedReconnectUrl);
                     assert.isTrue(mercury.connecting, 'Mercury is connecting');
 
                     // Block until reconnect completes so logs don't overlap