From 7487558b1115c0db41b91b835e44c773ea911556 Mon Sep 17 00:00:00 2001 From: Steven Zhang Date: Thu, 19 Nov 2026 13:58:09 -0500 Subject: [PATCH] fix: Apply FDv2 connection mode overrides after a network-driven offline setConnectionMode only reached the debounce through setRequestedMode, which ignores an unchanged mode. An override that matched the foreground mode after a network-driven offline never applied, and a cleared override had the same gap. setConnectionMode now requests a reconcile when the override changes and returns early when it does not, so repeated calls cannot hold back pending mode changes. --- .../datasource/FDv2DataManagerBase.test.ts | 105 ++++++++++++++++-- .../datasource/StateDebounceManager.test.ts | 14 +++ .../src/datasource/FDv2DataManagerBase.ts | 11 +- .../src/datasource/StateDebounceManager.ts | 12 +- 4 files changed, 126 insertions(+), 16 deletions(-) diff --git a/packages/shared/sdk-client/__tests__/datasource/FDv2DataManagerBase.test.ts b/packages/shared/sdk-client/__tests__/datasource/FDv2DataManagerBase.test.ts index 2c81f832b7..032048b246 100644 --- a/packages/shared/sdk-client/__tests__/datasource/FDv2DataManagerBase.test.ts +++ b/packages/shared/sdk-client/__tests__/datasource/FDv2DataManagerBase.test.ts @@ -109,6 +109,7 @@ let mockDebounceManager: { setNetworkState: jest.Mock; setLifecycleState: jest.Mock; setRequestedMode: jest.Mock; + requestReconcile: jest.Mock; close: jest.Mock; }; @@ -156,6 +157,7 @@ beforeEach(() => { setNetworkState: jest.fn(), setLifecycleState: jest.fn(), setRequestedMode: jest.fn(), + requestReconcile: jest.fn(), close: jest.fn(), }; @@ -564,10 +566,16 @@ it('setConnectionMode overrides all automatic behavior', async () => { const manager = createFDv2DataManagerBase(makeBaseConfig({ foregroundMode: 'streaming' })); await identifyManager(manager); - mockDebounceManager.setRequestedMode.mockClear(); + mockDebounceManager.requestReconcile.mockClear(); manager.setConnectionMode('polling'); + expect(mockDebounceManager.requestReconcile).toHaveBeenCalledTimes(1); - expect(mockDebounceManager.setRequestedMode).toHaveBeenCalledWith('polling'); + capturedOnReconcile!({ + networkState: 'available', + lifecycleState: 'foreground', + requestedMode: 'streaming', + }); + expect(manager.getCurrentMode()).toBe('polling'); manager.close(); }); @@ -577,17 +585,16 @@ it('setConnectionMode overrides forced streaming', async () => { await identifyManager(manager); manager.setForcedStreaming!(true); - mockDebounceManager.setRequestedMode.mockClear(); + mockDebounceManager.requestReconcile.mockClear(); manager.setConnectionMode('polling'); + expect(mockDebounceManager.requestReconcile).toHaveBeenCalledTimes(1); - expect(mockDebounceManager.setRequestedMode).toHaveBeenCalledWith('polling'); - - // onReconcile should resolve to 'polling' (override bypasses transition table) + // The override bypasses the transition table, so the forced streaming input loses. capturedOnReconcile!({ networkState: 'available', lifecycleState: 'foreground', - requestedMode: 'polling', + requestedMode: 'streaming', }); expect(manager.getCurrentMode()).toBe('polling'); @@ -600,12 +607,90 @@ it('clearing setConnectionMode returns to streaming logic', async () => { manager.setForcedStreaming!(true); manager.setConnectionMode('polling'); - mockDebounceManager.setRequestedMode.mockClear(); + capturedOnReconcile!({ + networkState: 'available', + lifecycleState: 'foreground', + requestedMode: 'streaming', + }); + expect(manager.getCurrentMode()).toBe('polling'); + mockDebounceManager.requestReconcile.mockClear(); - // Clear the override — should fall back to forced streaming + // Without the override, the forced streaming input decides the mode again. manager.setConnectionMode(undefined); + expect(mockDebounceManager.requestReconcile).toHaveBeenCalledTimes(1); - expect(mockDebounceManager.setRequestedMode).toHaveBeenCalledWith('streaming'); + capturedOnReconcile!({ + networkState: 'available', + lifecycleState: 'foreground', + requestedMode: 'streaming', + }); + expect(manager.getCurrentMode()).toBe('streaming'); + + manager.close(); +}); + +it('does not request a reconcile when setConnectionMode repeats the current override', async () => { + const manager = createFDv2DataManagerBase(makeBaseConfig({ foregroundMode: 'streaming' })); + await identifyManager(manager); + + manager.setConnectionMode('polling'); + mockDebounceManager.requestReconcile.mockClear(); + + manager.setConnectionMode('polling'); + manager.setConnectionMode('polling'); + + expect(mockDebounceManager.requestReconcile).not.toHaveBeenCalled(); + + manager.close(); +}); + +it('does not request a reconcile when setConnectionMode clears an override that is not set', async () => { + const manager = createFDv2DataManagerBase(makeBaseConfig({ foregroundMode: 'streaming' })); + await identifyManager(manager); + mockDebounceManager.requestReconcile.mockClear(); + + manager.setConnectionMode(undefined); + + expect(mockDebounceManager.requestReconcile).not.toHaveBeenCalled(); + + manager.close(); +}); + +it('requests a reconcile when setConnectionMode repeats the requested mode', async () => { + const manager = createFDv2DataManagerBase(makeBaseConfig({ foregroundMode: 'streaming' })); + await identifyManager(manager); + + // The network moves the data system offline. The requested mode stays 'streaming'. + capturedOnReconcile!({ + networkState: 'unavailable', + lifecycleState: 'foreground', + requestedMode: 'streaming', + }); + expect(manager.getCurrentMode()).toBe('offline'); + + mockDebounceManager.requestReconcile.mockClear(); + manager.setConnectionMode('streaming'); + expect(mockDebounceManager.requestReconcile).toHaveBeenCalledTimes(1); + + capturedOnReconcile!({ + networkState: 'unavailable', + lifecycleState: 'foreground', + requestedMode: 'streaming', + }); + expect(manager.getCurrentMode()).toBe('streaming'); + + manager.close(); +}); + +it('requests a reconcile when setConnectionMode clears the override', async () => { + const manager = createFDv2DataManagerBase(makeBaseConfig({ foregroundMode: 'streaming' })); + await identifyManager(manager); + + manager.setConnectionMode('streaming'); + mockDebounceManager.requestReconcile.mockClear(); + + manager.setConnectionMode(undefined); + expect(mockDebounceManager.requestReconcile).toHaveBeenCalledTimes(1); manager.close(); }); diff --git a/packages/shared/sdk-client/__tests__/datasource/StateDebounceManager.test.ts b/packages/shared/sdk-client/__tests__/datasource/StateDebounceManager.test.ts index 4edcea2196..ebe039bfca 100644 --- a/packages/shared/sdk-client/__tests__/datasource/StateDebounceManager.test.ts +++ b/packages/shared/sdk-client/__tests__/datasource/StateDebounceManager.test.ts @@ -81,6 +81,20 @@ it('fires callback after debounce window when connection mode changes', () => { manager.close(); }); +it('fires callback after debounce window when a reconcile is requested without a state change', () => { + const { manager, onReconcile } = makeManager(); + + manager.requestReconcile(); + jest.advanceTimersByTime(DEFAULT_DEBOUNCE_MS - 1); + expect(onReconcile).not.toHaveBeenCalled(); + + jest.advanceTimersByTime(1); + expect(onReconcile).toHaveBeenCalledTimes(1); + expect(onReconcile).toHaveBeenCalledWith(defaultInitialState); + + manager.close(); +}); + it('resets the timer when a new event arrives within the debounce window', () => { const { manager, onReconcile } = makeManager(); diff --git a/packages/shared/sdk-client/src/datasource/FDv2DataManagerBase.ts b/packages/shared/sdk-client/src/datasource/FDv2DataManagerBase.ts index dd5a1b4251..f31753b6a6 100644 --- a/packages/shared/sdk-client/src/datasource/FDv2DataManagerBase.ts +++ b/packages/shared/sdk-client/src/datasource/FDv2DataManagerBase.ts @@ -642,12 +642,13 @@ export function createFDv2DataManagerBase( }, setConnectionMode(mode?: FDv2ConnectionMode): void { - connectionModeOverride = mode; - if (mode !== undefined) { - debounceManager?.setRequestedMode(mode); - } else { - pushForegroundMode(); + // The pending state does not hold the override, so an override change requests the + // reconcile itself. A repeated call does not, so it cannot hold back a pending transition. + if (connectionModeOverride === mode) { + return; } + connectionModeOverride = mode; + debounceManager?.requestReconcile(); }, getCurrentMode(): FDv2ConnectionMode { diff --git a/packages/shared/sdk-client/src/datasource/StateDebounceManager.ts b/packages/shared/sdk-client/src/datasource/StateDebounceManager.ts index 1dc2e41cf0..c885d22415 100644 --- a/packages/shared/sdk-client/src/datasource/StateDebounceManager.ts +++ b/packages/shared/sdk-client/src/datasource/StateDebounceManager.ts @@ -63,9 +63,15 @@ export interface StateDebounceManager { */ setRequestedMode(mode: FDv2ConnectionMode): void; + /** + * Resets the debounce timer without a change to the pending state. Use it when an input that + * the pending state does not hold, such as the connection mode override, changes. + */ + requestReconcile(): void; + /** * Cancel any pending debounce timer and release resources. - * After close(), further calls to set* methods will not + * After close(), further calls to the update methods will not * trigger reconciliation. */ close(): void; @@ -157,6 +163,10 @@ export function createStateDebounceManager( resetTimer(); }, + requestReconcile(): void { + resetTimer(); + }, + close(): void { closed = true; if (timer !== undefined) {