From e5025eb13c65ecf145a69537ee73589e3758e109 Mon Sep 17 00:00:00 2001 From: cdaringe Date: Tue, 3 Nov 2026 15:36:21 -0800 Subject: [PATCH 1/7] feat: support dynamic heartbeat lookup --- Change-log.md | 4 ++ spec/unit/heartbeat-tolerance.spec.ts | 91 +++++++++++++++++++++++++++ src/client.ts | 11 +++- src/stomp-config.ts | 2 +- src/stomp-handler.ts | 8 ++- src/types.ts | 2 +- 6 files changed, 112 insertions(+), 6 deletions(-) create mode 100644 spec/unit/heartbeat-tolerance.spec.ts diff --git a/Change-log.md b/Change-log.md index 47a843c5..ab68562f 100644 --- a/Change-log.md +++ b/Change-log.md @@ -1,5 +1,9 @@ # Change Log +# Unreleased + +- Support a callback for `heartbeatToleranceMultiplier`, evaluated on every incoming heartbeat check ([#755](https://github.com/stomp-js/stompjs/issues/755)). + # 7.5.0 (2026-10-15) - Fix [#743](https://github.com/stomp-js/stompjs/issues/743) diff --git a/spec/unit/heartbeat-tolerance.spec.ts b/spec/unit/heartbeat-tolerance.spec.ts new file mode 100644 index 00000000..3e3a7cd4 --- /dev/null +++ b/spec/unit/heartbeat-tolerance.spec.ts @@ -0,0 +1,91 @@ +import { expect, test } from '@playwright/test'; +import sinon from 'sinon'; +import { Client } from '../../src/client.js'; + +test.describe('Heartbeat tolerance lookup', () => { + let clock: sinon.SinonFakeTimers; + let client: Client; + let socket: any; + let lost: sinon.SinonSpy; + + test.beforeEach(() => { + clock = sinon.useFakeTimers({ + toFake: ['Date', 'setInterval', 'clearInterval'], + }); + lost = sinon.spy(); + socket = { + readyState: 1, + send: sinon.spy(), + close: sinon.spy(), + }; + }); + + test.afterEach(async () => { + await client?.deactivate({ force: true }); + clock.restore(); + }); + + async function connect( + multiplier: number | (() => number), + serverInterval = 1000, + ) { + client = new Client({ + webSocketFactory: () => socket, + heartbeatIncoming: 1000, + heartbeatOutgoing: 0, + heartbeatToleranceMultiplier: multiplier, + onHeartbeatLost: lost, + reconnectDelay: 0, + }); + client.activate(); + await clock.tickAsync(0); + socket.onmessage({ + data: `CONNECTED\nversion:1.2\nheart-beat:${serverInterval},0\n\n\0`, + }); + } + + test('preserves numeric tolerance and the strict timeout boundary', async () => { + await connect(2); + await clock.tickAsync(2000); + expect(lost.called).toBe(false); + await clock.tickAsync(1000); + expect(lost.calledOnce).toBe(true); + expect(socket.close.calledOnce).toBe(true); + }); + + test('looks up changing tolerance on every check without reconnecting', async () => { + let multiplier = 2; + const lookup = sinon.spy(() => multiplier); + await connect(lookup); + expect(lookup.called).toBe(false); + await clock.tickAsync(1000); + expect(lookup.callCount).toBe(1); + + multiplier = 4; + await clock.tickAsync(2000); + expect(lookup.callCount).toBe(3); + expect(lost.called).toBe(false); + + multiplier = 1; + await clock.tickAsync(1000); + expect(lookup.callCount).toBe(4); + expect(lost.calledOnce).toBe(true); + expect(socket.close.calledOnce).toBe(true); + }); + + test('applies the callback to the negotiated interval', async () => { + await connect(() => 2, 2000); + await clock.tickAsync(4000); + expect(lost.called).toBe(false); + await clock.tickAsync(2000); + expect(lost.calledOnce).toBe(true); + }); + + test('does not look up tolerance when incoming heartbeats are disabled by the server', async () => { + const lookup = sinon.spy(() => 2); + await connect(lookup, 0); + await clock.tickAsync(10000); + expect(lookup.called).toBe(false); + expect(lost.called).toBe(false); + }); +}); diff --git a/src/client.ts b/src/client.ts index 0289e48a..e8c321f9 100644 --- a/src/client.ts +++ b/src/client.ts @@ -174,17 +174,24 @@ export class Client { * Multiplier for adjusting tolerance when processing heartbeat signals. * * Tolerance level is calculated using the multiplier: - * `tolerance = heartbeatIncoming * heartbeatToleranceMultiplier`. + * `tolerance = negotiatedIncomingInterval * multiplier`, where the interval is + * the maximum of `heartbeatIncoming` and the server's outgoing heartbeat interval. * This helps account for delays in network communication or variations in timings. * + * Supply a synchronous callback to look up the multiplier on every incoming + * heartbeat check. Its return value can change during an active connection, + * without reconnecting. This does not change the negotiated heartbeat interval. + * * Default value is `2`. * * Example: * ```javascript * client.heartbeatToleranceMultiplier = 2.5; // Tolerates longer delays + * // Or adapt tolerance as network conditions change: + * client.heartbeatToleranceMultiplier = () => currentNetworkMultiplier; * ``` */ - public heartbeatToleranceMultiplier: number = 2; + public heartbeatToleranceMultiplier: number | (() => number) = 2; /** * Interval (in milliseconds) for sending heartbeat signals to the server. diff --git a/src/stomp-config.ts b/src/stomp-config.ts index fb44ac7b..38c100df 100644 --- a/src/stomp-config.ts +++ b/src/stomp-config.ts @@ -64,7 +64,7 @@ export class StompConfig { /** * See [Client#heartbeatToleranceMultiplier]{@link Client#heartbeatToleranceMultiplier}. */ - public heartbeatToleranceMultiplier?: number; + public heartbeatToleranceMultiplier?: number | (() => number); /** * See [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. diff --git a/src/stomp-handler.ts b/src/stomp-handler.ts index 4c3a57e0..8be1a8b7 100644 --- a/src/stomp-handler.ts +++ b/src/stomp-handler.ts @@ -41,7 +41,7 @@ export class StompHandler { public heartbeatIncoming: number; - public heartbeatToleranceMultiplier: number; + public heartbeatToleranceMultiplier: number | (() => number); public heartbeatOutgoing: number; @@ -338,7 +338,11 @@ export class StompHandler { this._ponger = setInterval(() => { const delta = Date.now() - this._lastServerActivityTS; // We wait multiple grace periods to be flexible on window's setInterval calls - if (delta > ttl * this.heartbeatToleranceMultiplier) { + const multiplier = + typeof this.heartbeatToleranceMultiplier === 'function' + ? this.heartbeatToleranceMultiplier() + : this.heartbeatToleranceMultiplier; + if (delta > ttl * multiplier) { this.debug(`did not receive server activity for the last ${delta}ms`); this.onHeartbeatLost(); this._closeOrDiscardWebsocket(); diff --git a/src/types.ts b/src/types.ts index 7b10abc8..31688b89 100644 --- a/src/types.ts +++ b/src/types.ts @@ -189,7 +189,7 @@ export interface IStomptHandlerConfig { connectHeaders: StompHeaders; disconnectHeaders: StompHeaders; heartbeatIncoming: number; - heartbeatGracePeriods: number; + heartbeatGracePeriods: number | (() => number); heartbeatOutgoing: number; heartbeatStrategy: TickerStrategy; splitLargeFrames: boolean; From 39aa50694d1ad063bdb81b5c0eb0c275ef7f8355 Mon Sep 17 00:00:00 2001 From: cdaringe Date: Tue, 3 Nov 2026 15:38:31 -0800 Subject: [PATCH 2/7] test: simplify dynamic heartbeat coverage and revert API comments --- spec/unit/heart-beat-callback.spec.ts | 73 +++++++++++++++++++++ spec/unit/heartbeat-tolerance.spec.ts | 91 --------------------------- src/client.ts | 9 +-- 3 files changed, 74 insertions(+), 99 deletions(-) delete mode 100644 spec/unit/heartbeat-tolerance.spec.ts diff --git a/spec/unit/heart-beat-callback.spec.ts b/spec/unit/heart-beat-callback.spec.ts index 483048b4..5b48df1e 100644 --- a/spec/unit/heart-beat-callback.spec.ts +++ b/spec/unit/heart-beat-callback.spec.ts @@ -1,5 +1,6 @@ import { expect, test } from '@playwright/test'; import sinon from 'sinon'; +import { Client } from '../../src/client.js'; import { disconnectStomp, overRideFactory, @@ -90,3 +91,75 @@ test.describe('Client heartbeat handling (callbacks)', () => { }); }); }); + +test.describe('Heartbeat tolerance lookup', () => { + let clock: sinon.SinonFakeTimers; + let client: Client; + let socket: any; + let lost: sinon.SinonSpy; + + test.beforeEach(() => { + clock = sinon.useFakeTimers({ + toFake: ['Date', 'setInterval', 'clearInterval'], + }); + lost = sinon.spy(); + socket = { + readyState: 1, + send: sinon.spy(), + close: sinon.spy(), + }; + }); + + test.afterEach(async () => { + await client?.deactivate({ force: true }); + clock.restore(); + }); + + async function connect( + multiplier: number | (() => number), + serverInterval = 1000, + ) { + client = new Client({ + webSocketFactory: () => socket, + heartbeatIncoming: 1000, + heartbeatOutgoing: 0, + heartbeatToleranceMultiplier: multiplier, + onHeartbeatLost: lost, + reconnectDelay: 0, + }); + client.activate(); + await clock.tickAsync(0); + socket.onmessage({ + data: `CONNECTED\nversion:1.2\nheart-beat:${serverInterval},0\n\n\0`, + }); + } + + test('looks up changing tolerance on every check without reconnecting', async () => { + let multiplier = 2; + const lookup = sinon.spy(() => multiplier); + await connect(lookup); + expect(lookup.called).toBe(false); + await clock.tickAsync(1000); + expect(lookup.callCount).toBe(1); + + multiplier = 4; + await clock.tickAsync(2000); + expect(lookup.callCount).toBe(3); + expect(lost.called).toBe(false); + + multiplier = 1; + await clock.tickAsync(1000); + expect(lookup.callCount).toBe(4); + expect(lost.calledOnce).toBe(true); + expect(socket.close.calledOnce).toBe(true); + }); + + test('applies the callback to the negotiated interval', async () => { + await connect(() => 2, 2000); + await clock.tickAsync(4000); + expect(lost.called).toBe(false); + await clock.tickAsync(2000); + expect(lost.calledOnce).toBe(true); + }); + +}); diff --git a/spec/unit/heartbeat-tolerance.spec.ts b/spec/unit/heartbeat-tolerance.spec.ts deleted file mode 100644 index 3e3a7cd4..00000000 --- a/spec/unit/heartbeat-tolerance.spec.ts +++ /dev/null @@ -1,91 +0,0 @@ -import { expect, test } from '@playwright/test'; -import sinon from 'sinon'; -import { Client } from '../../src/client.js'; - -test.describe('Heartbeat tolerance lookup', () => { - let clock: sinon.SinonFakeTimers; - let client: Client; - let socket: any; - let lost: sinon.SinonSpy; - - test.beforeEach(() => { - clock = sinon.useFakeTimers({ - toFake: ['Date', 'setInterval', 'clearInterval'], - }); - lost = sinon.spy(); - socket = { - readyState: 1, - send: sinon.spy(), - close: sinon.spy(), - }; - }); - - test.afterEach(async () => { - await client?.deactivate({ force: true }); - clock.restore(); - }); - - async function connect( - multiplier: number | (() => number), - serverInterval = 1000, - ) { - client = new Client({ - webSocketFactory: () => socket, - heartbeatIncoming: 1000, - heartbeatOutgoing: 0, - heartbeatToleranceMultiplier: multiplier, - onHeartbeatLost: lost, - reconnectDelay: 0, - }); - client.activate(); - await clock.tickAsync(0); - socket.onmessage({ - data: `CONNECTED\nversion:1.2\nheart-beat:${serverInterval},0\n\n\0`, - }); - } - - test('preserves numeric tolerance and the strict timeout boundary', async () => { - await connect(2); - await clock.tickAsync(2000); - expect(lost.called).toBe(false); - await clock.tickAsync(1000); - expect(lost.calledOnce).toBe(true); - expect(socket.close.calledOnce).toBe(true); - }); - - test('looks up changing tolerance on every check without reconnecting', async () => { - let multiplier = 2; - const lookup = sinon.spy(() => multiplier); - await connect(lookup); - expect(lookup.called).toBe(false); - await clock.tickAsync(1000); - expect(lookup.callCount).toBe(1); - - multiplier = 4; - await clock.tickAsync(2000); - expect(lookup.callCount).toBe(3); - expect(lost.called).toBe(false); - - multiplier = 1; - await clock.tickAsync(1000); - expect(lookup.callCount).toBe(4); - expect(lost.calledOnce).toBe(true); - expect(socket.close.calledOnce).toBe(true); - }); - - test('applies the callback to the negotiated interval', async () => { - await connect(() => 2, 2000); - await clock.tickAsync(4000); - expect(lost.called).toBe(false); - await clock.tickAsync(2000); - expect(lost.calledOnce).toBe(true); - }); - - test('does not look up tolerance when incoming heartbeats are disabled by the server', async () => { - const lookup = sinon.spy(() => 2); - await connect(lookup, 0); - await clock.tickAsync(10000); - expect(lookup.called).toBe(false); - expect(lost.called).toBe(false); - }); -}); diff --git a/src/client.ts b/src/client.ts index e8c321f9..139c0041 100644 --- a/src/client.ts +++ b/src/client.ts @@ -174,21 +174,14 @@ export class Client { * Multiplier for adjusting tolerance when processing heartbeat signals. * * Tolerance level is calculated using the multiplier: - * `tolerance = negotiatedIncomingInterval * multiplier`, where the interval is - * the maximum of `heartbeatIncoming` and the server's outgoing heartbeat interval. + * `tolerance = heartbeatIncoming * heartbeatToleranceMultiplier`. * This helps account for delays in network communication or variations in timings. * - * Supply a synchronous callback to look up the multiplier on every incoming - * heartbeat check. Its return value can change during an active connection, - * without reconnecting. This does not change the negotiated heartbeat interval. - * * Default value is `2`. * * Example: * ```javascript * client.heartbeatToleranceMultiplier = 2.5; // Tolerates longer delays - * // Or adapt tolerance as network conditions change: - * client.heartbeatToleranceMultiplier = () => currentNetworkMultiplier; * ``` */ public heartbeatToleranceMultiplier: number | (() => number) = 2; From dce869b00165291b3a5cb87dacee28ea16d4e5a1 Mon Sep 17 00:00:00 2001 From: cdaringe Date: Tue, 3 Nov 2026 15:39:45 -0800 Subject: [PATCH 3/7] refactor: share heartbeat tolerance multiplier type --- spec/unit/heart-beat-callback.spec.ts | 3 ++- src/client.ts | 3 ++- src/stomp-config.ts | 3 ++- src/stomp-handler.ts | 3 ++- src/types.ts | 9 ++++++++- 5 files changed, 16 insertions(+), 5 deletions(-) diff --git a/spec/unit/heart-beat-callback.spec.ts b/spec/unit/heart-beat-callback.spec.ts index 5b48df1e..3c0886d8 100644 --- a/spec/unit/heart-beat-callback.spec.ts +++ b/spec/unit/heart-beat-callback.spec.ts @@ -1,6 +1,7 @@ import { expect, test } from '@playwright/test'; import sinon from 'sinon'; import { Client } from '../../src/client.js'; +import type { HeartbeatToleranceMultiplier } from '../../src/types.js'; import { disconnectStomp, overRideFactory, @@ -116,7 +117,7 @@ test.describe('Heartbeat tolerance lookup', () => { }); async function connect( - multiplier: number | (() => number), + multiplier: HeartbeatToleranceMultiplier, serverInterval = 1000, ) { client = new Client({ diff --git a/src/client.ts b/src/client.ts index 139c0041..62f5de05 100644 --- a/src/client.ts +++ b/src/client.ts @@ -7,6 +7,7 @@ import { ActivationState, closeEventCallbackType, debugFnType, + HeartbeatToleranceMultiplier, emptyCallbackType, frameCallbackType, IPublishParams, @@ -184,7 +185,7 @@ export class Client { * client.heartbeatToleranceMultiplier = 2.5; // Tolerates longer delays * ``` */ - public heartbeatToleranceMultiplier: number | (() => number) = 2; + public heartbeatToleranceMultiplier: HeartbeatToleranceMultiplier = 2; /** * Interval (in milliseconds) for sending heartbeat signals to the server. diff --git a/src/stomp-config.ts b/src/stomp-config.ts index 38c100df..a782d147 100644 --- a/src/stomp-config.ts +++ b/src/stomp-config.ts @@ -4,6 +4,7 @@ import { TickerStrategy, closeEventCallbackType, debugFnType, + HeartbeatToleranceMultiplier, frameCallbackType, messageCallbackType, ReconnectionTimeMode, @@ -64,7 +65,7 @@ export class StompConfig { /** * See [Client#heartbeatToleranceMultiplier]{@link Client#heartbeatToleranceMultiplier}. */ - public heartbeatToleranceMultiplier?: number | (() => number); + public heartbeatToleranceMultiplier?: HeartbeatToleranceMultiplier; /** * See [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. diff --git a/src/stomp-handler.ts b/src/stomp-handler.ts index 8be1a8b7..f7a52e99 100644 --- a/src/stomp-handler.ts +++ b/src/stomp-handler.ts @@ -10,6 +10,7 @@ import { Ticker } from './ticker.js'; import { closeEventCallbackType, debugFnType, + HeartbeatToleranceMultiplier, emptyCallbackType, frameCallbackType, IPublishParams, @@ -41,7 +42,7 @@ export class StompHandler { public heartbeatIncoming: number; - public heartbeatToleranceMultiplier: number | (() => number); + public heartbeatToleranceMultiplier: HeartbeatToleranceMultiplier; public heartbeatOutgoing: number; diff --git a/src/types.ts b/src/types.ts index 31688b89..80f71b5c 100644 --- a/src/types.ts +++ b/src/types.ts @@ -10,6 +10,13 @@ import { Versions } from './versions.js'; */ export type debugFnType = (msg: string) => void; +/** + * Incoming heartbeat tolerance multiplier, or a synchronous lookup evaluated on each check. + * + * Part of `@stomp/stompjs`. + */ +export type HeartbeatToleranceMultiplier = number | (() => number); + /** * This callback will receive a {@link IMessage} as parameter. * @@ -189,7 +196,7 @@ export interface IStomptHandlerConfig { connectHeaders: StompHeaders; disconnectHeaders: StompHeaders; heartbeatIncoming: number; - heartbeatGracePeriods: number | (() => number); + heartbeatGracePeriods: HeartbeatToleranceMultiplier; heartbeatOutgoing: number; heartbeatStrategy: TickerStrategy; splitLargeFrames: boolean; From c48435c9b36082b051409d197a7115757d46bfc2 Mon Sep 17 00:00:00 2001 From: cdaringe Date: Tue, 3 Nov 2026 15:42:58 -0800 Subject: [PATCH 4/7] test: clarify heartbeat multiplier callback name --- spec/unit/heart-beat-callback.spec.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/spec/unit/heart-beat-callback.spec.ts b/spec/unit/heart-beat-callback.spec.ts index 3c0886d8..43aef4d9 100644 --- a/spec/unit/heart-beat-callback.spec.ts +++ b/spec/unit/heart-beat-callback.spec.ts @@ -137,20 +137,20 @@ test.describe('Heartbeat tolerance lookup', () => { test('looks up changing tolerance on every check without reconnecting', async () => { let multiplier = 2; - const lookup = sinon.spy(() => multiplier); - await connect(lookup); - expect(lookup.called).toBe(false); + const getHeartbeatMultiplier = sinon.spy(() => multiplier); + await connect(getHeartbeatMultiplier); + expect(getHeartbeatMultiplier.called).toBe(false); await clock.tickAsync(1000); - expect(lookup.callCount).toBe(1); + expect(getHeartbeatMultiplier.callCount).toBe(1); multiplier = 4; await clock.tickAsync(2000); - expect(lookup.callCount).toBe(3); + expect(getHeartbeatMultiplier.callCount).toBe(3); expect(lost.called).toBe(false); multiplier = 1; await clock.tickAsync(1000); - expect(lookup.callCount).toBe(4); + expect(getHeartbeatMultiplier.callCount).toBe(4); expect(lost.calledOnce).toBe(true); expect(socket.close.calledOnce).toBe(true); }); From efed704dd941edda90f90c821942cea07a1d95f3 Mon Sep 17 00:00:00 2001 From: cdaringe Date: Tue, 3 Nov 2026 15:43:48 -0800 Subject: [PATCH 5/7] Apply suggestion from @cdaringe --- src/types.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/types.ts b/src/types.ts index 80f71b5c..622eb14e 100644 --- a/src/types.ts +++ b/src/types.ts @@ -12,8 +12,6 @@ export type debugFnType = (msg: string) => void; /** * Incoming heartbeat tolerance multiplier, or a synchronous lookup evaluated on each check. - * - * Part of `@stomp/stompjs`. */ export type HeartbeatToleranceMultiplier = number | (() => number); From f61b4b6619c7dc2c8620b8e248bd8827e9118027 Mon Sep 17 00:00:00 2001 From: cdaringe Date: Wed, 11 Nov 2026 21:14:28 -0800 Subject: [PATCH 6/7] test: align heartbeat tolerance coverage with review feedback --- spec/unit/heart-beat-callback.spec.ts | 143 ++++++++++++++++---------- src/client.ts | 1 + 2 files changed, 90 insertions(+), 54 deletions(-) diff --git a/spec/unit/heart-beat-callback.spec.ts b/spec/unit/heart-beat-callback.spec.ts index 43aef4d9..0eec5991 100644 --- a/spec/unit/heart-beat-callback.spec.ts +++ b/spec/unit/heart-beat-callback.spec.ts @@ -1,14 +1,14 @@ import { expect, test } from '@playwright/test'; import sinon from 'sinon'; -import { Client } from '../../src/client.js'; -import type { HeartbeatToleranceMultiplier } from '../../src/types.js'; +import { Client, FrameImpl } from '../../src/index.js'; import { disconnectStomp, overRideFactory, stompClient, } from '../helpers/connect-helpers.js'; import { WrapperWS } from '../helpers/wrapper-ws.js'; -import { getLength } from '../helpers/utils.js'; +import { getLength, wait } from '../helpers/utils.js'; +import { parseFrame } from '../helpers/parse-frame.js'; test.describe('Client heartbeat handling (callbacks)', () => { let client: any; @@ -94,73 +94,108 @@ test.describe('Client heartbeat handling (callbacks)', () => { }); test.describe('Heartbeat tolerance lookup', () => { - let clock: sinon.SinonFakeTimers; let client: Client; - let socket: any; - let lost: sinon.SinonSpy; test.beforeEach(() => { - clock = sinon.useFakeTimers({ - toFake: ['Date', 'setInterval', 'clearInterval'], - }); - lost = sinon.spy(); - socket = { - readyState: 1, - send: sinon.spy(), - close: sinon.spy(), - }; + client = stompClient(); + client.heartbeatIncoming = 1000; + client.heartbeatOutgoing = 0; + + overRideFactory( + client, + class extends WrapperWS { + wrapOnMessage(ev: any) { + // Eat away incoming pings so the client's tolerance determines closure. + if (getLength(ev.data) === 1) { + return; + } + super.wrapOnMessage(ev); + } + }, + ); }); test.afterEach(async () => { - await client?.deactivate({ force: true }); - clock.restore(); + await disconnectStomp(client); }); - async function connect( - multiplier: HeartbeatToleranceMultiplier, - serverInterval = 1000, - ) { - client = new Client({ - webSocketFactory: () => socket, - heartbeatIncoming: 1000, - heartbeatOutgoing: 0, - heartbeatToleranceMultiplier: multiplier, - onHeartbeatLost: lost, - reconnectDelay: 0, - }); - client.activate(); - await clock.tickAsync(0); - socket.onmessage({ - data: `CONNECTED\nversion:1.2\nheart-beat:${serverInterval},0\n\n\0`, - }); - } - test('looks up changing tolerance on every check without reconnecting', async () => { let multiplier = 2; const getHeartbeatMultiplier = sinon.spy(() => multiplier); - await connect(getHeartbeatMultiplier); - expect(getHeartbeatMultiplier.called).toBe(false); - await clock.tickAsync(1000); - expect(getHeartbeatMultiplier.callCount).toBe(1); + const onHeartbeatLost = sinon.spy(); + const onConnect = sinon.spy(); + client.heartbeatToleranceMultiplier = getHeartbeatMultiplier; + client.onHeartbeatLost = onHeartbeatLost; + const closed = new Promise(resolve => { + client.onWebSocketClose = () => resolve(); + }); - multiplier = 4; - await clock.tickAsync(2000); - expect(getHeartbeatMultiplier.callCount).toBe(3); - expect(lost.called).toBe(false); + await new Promise(resolve => { + client.onConnect = () => { + onConnect(); + resolve(); + }; + client.activate(); + }); + expect(getHeartbeatMultiplier.called).toBe(false); + await expect + .poll(() => getHeartbeatMultiplier.callCount) + .toBeGreaterThanOrEqual(1); + + multiplier = 10; + await expect + .poll(() => getHeartbeatMultiplier.callCount) + .toBeGreaterThanOrEqual(3); + expect(onHeartbeatLost.called).toBe(false); + expect(client.connected).toBe(true); + expect(onConnect.calledOnce).toBe(true); multiplier = 1; - await clock.tickAsync(1000); - expect(getHeartbeatMultiplier.callCount).toBe(4); - expect(lost.calledOnce).toBe(true); - expect(socket.close.calledOnce).toBe(true); + await closed; + expect(getHeartbeatMultiplier.callCount).toBeGreaterThanOrEqual(4); + expect(onHeartbeatLost.calledOnce).toBe(true); + expect(client.connected).toBe(false); + expect(onConnect.calledOnce).toBe(true); }); test('applies the callback to the negotiated interval', async () => { - await connect(() => 2, 2000); - await clock.tickAsync(4000); - expect(lost.called).toBe(false); - await clock.tickAsync(2000); - expect(lost.calledOnce).toBe(true); - }); + const onHeartbeatLost = sinon.spy(); + client.heartbeatToleranceMultiplier = () => 2; + client.onHeartbeatLost = onHeartbeatLost; + + overRideFactory( + client, + class extends WrapperWS { + wrapOnMessage(ev: any) { + if (getLength(ev.data) === 1) { + return; + } + const incomingFrame = parseFrame(ev.data); + if (incomingFrame.command === 'CONNECTED') { + const frame = FrameImpl.fromRawFrame(incomingFrame, true); + frame.headers['heart-beat'] = '2000,0'; + ev = { data: frame.serialize() }; + } + super.wrapOnMessage(ev); + } + }, + ); + + const closed = new Promise(resolve => { + client.onWebSocketClose = () => resolve(); + }); + await new Promise(resolve => { + client.onConnect = () => resolve(); + client.activate(); + }); + + // Beyond the unnegotiated 1000 * 2 tolerance, but within 2000 * 2. + await wait(3000); + expect(onHeartbeatLost.called).toBe(false); + expect(client.connected).toBe(true); + await closed; + expect(onHeartbeatLost.calledOnce).toBe(true); + expect(client.connected).toBe(false); + }); }); diff --git a/src/client.ts b/src/client.ts index 62f5de05..f6c34578 100644 --- a/src/client.ts +++ b/src/client.ts @@ -173,6 +173,7 @@ export class Client { /** * Multiplier for adjusting tolerance when processing heartbeat signals. + * Accepts a number or a function of type `() => number`. * * Tolerance level is calculated using the multiplier: * `tolerance = heartbeatIncoming * heartbeatToleranceMultiplier`. From b5f49b746ccde4fc6019fdc3297b5d57ad9d863d Mon Sep 17 00:00:00 2001 From: cdaringe Date: Wed, 11 Nov 2026 21:22:03 -0800 Subject: [PATCH 7/7] test: shorten heartbeat tolerance timing windows --- spec/unit/heart-beat-callback.spec.ts | 41 ++++++++++++--------------- 1 file changed, 18 insertions(+), 23 deletions(-) diff --git a/spec/unit/heart-beat-callback.spec.ts b/spec/unit/heart-beat-callback.spec.ts index 0eec5991..a5e84874 100644 --- a/spec/unit/heart-beat-callback.spec.ts +++ b/spec/unit/heart-beat-callback.spec.ts @@ -95,20 +95,31 @@ test.describe('Client heartbeat handling (callbacks)', () => { test.describe('Heartbeat tolerance lookup', () => { let client: Client; + let serverHeartbeatInterval: number; test.beforeEach(() => { client = stompClient(); - client.heartbeatIncoming = 1000; + client.heartbeatIncoming = 250; + serverHeartbeatInterval = 250; client.heartbeatOutgoing = 0; overRideFactory( client, class extends WrapperWS { wrapOnMessage(ev: any) { - // Eat away incoming pings so the client's tolerance determines closure. + // Drop the server's heartbeat messages to simulate missed heartbeats. + // The client should close the connection once its tolerance is exceeded. if (getLength(ev.data) === 1) { return; } + const incomingFrame = parseFrame(ev.data); + if (incomingFrame.command === 'CONNECTED') { + const frame = FrameImpl.fromRawFrame(incomingFrame, true); + // Advertise a shorter interval to speed up the client's checks. + // The connection and timers remain real; server heartbeats are dropped above. + frame.headers['heart-beat'] = `${serverHeartbeatInterval},0`; + ev = { data: frame.serialize() }; + } super.wrapOnMessage(ev); } }, @@ -139,12 +150,12 @@ test.describe('Heartbeat tolerance lookup', () => { }); expect(getHeartbeatMultiplier.called).toBe(false); await expect - .poll(() => getHeartbeatMultiplier.callCount) + .poll(() => getHeartbeatMultiplier.callCount, { intervals: [20, 40, 50] }) .toBeGreaterThanOrEqual(1); multiplier = 10; await expect - .poll(() => getHeartbeatMultiplier.callCount) + .poll(() => getHeartbeatMultiplier.callCount, { intervals: [20, 40, 50] }) .toBeGreaterThanOrEqual(3); expect(onHeartbeatLost.called).toBe(false); expect(client.connected).toBe(true); @@ -163,23 +174,7 @@ test.describe('Heartbeat tolerance lookup', () => { client.heartbeatToleranceMultiplier = () => 2; client.onHeartbeatLost = onHeartbeatLost; - overRideFactory( - client, - class extends WrapperWS { - wrapOnMessage(ev: any) { - if (getLength(ev.data) === 1) { - return; - } - const incomingFrame = parseFrame(ev.data); - if (incomingFrame.command === 'CONNECTED') { - const frame = FrameImpl.fromRawFrame(incomingFrame, true); - frame.headers['heart-beat'] = '2000,0'; - ev = { data: frame.serialize() }; - } - super.wrapOnMessage(ev); - } - }, - ); + serverHeartbeatInterval = 500; const closed = new Promise(resolve => { client.onWebSocketClose = () => resolve(); @@ -189,8 +184,8 @@ test.describe('Heartbeat tolerance lookup', () => { client.activate(); }); - // Beyond the unnegotiated 1000 * 2 tolerance, but within 2000 * 2. - await wait(3000); + // Beyond the unnegotiated 250 * 2 tolerance, but within 500 * 2. + await wait(750); expect(onHeartbeatLost.called).toBe(false); expect(client.connected).toBe(true);