import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import { runScenarios } from '../../../scripts/test-scenarios.mjs' import { ForegroundConnectionRecovery } from '../src/services/connection-recovery' type RecoveryState = ReturnType[0]> let state: RecoveryState let recovery: ForegroundConnectionRecovery let reconnect: ReturnType Promise>> let exhausted: ReturnType function prepare() { vi.clearAllTimers() vi.useFakeTimers() state = { connection: { phase: 'connected', stats: { mode: 'P2P' } }, selectedDevice: { deviceId: 'host-1' }, reauthRequired: false, transportPreference: 'auto', } reconnect = vi.fn(async () => false) exhausted = vi.fn() recovery = new ForegroundConnectionRecovery(() => state, reconnect, exhausted) recovery.setActive(true) } function offline() { state = { ...state, connection: { phase: 'offline', stats: { mode: 'Disconnected' } } } recovery.update() } beforeEach(prepare) afterEach(() => { recovery.setActive(false); vi.useRealTimers() }) describe('foreground carrier recovery', () => { it('bounds retries and preserves explicit transport choices', async () => { await runScenarios(['auto', 'turn', 'relay'].map(preference => ({ name: preference, run: async () => { state.transportPreference = preference as RecoveryState['transportPreference'] offline() recovery.update() // First retry is immediate (0ms) so a dropped P2P path heals over the // relay without a fixed startup delay. await vi.advanceTimersByTimeAsync(0) expect(reconnect).toHaveBeenCalledTimes(1) await vi.advanceTimersByTimeAsync(1_000) expect(reconnect).toHaveBeenCalledTimes(2) await vi.advanceTimersByTimeAsync(3_000) expect(reconnect).toHaveBeenCalledTimes(3) await vi.advanceTimersByTimeAsync(8_000) expect(reconnect).toHaveBeenCalledTimes(4) await vi.advanceTimersByTimeAsync(15_000 + 30_000 + 30_000 + 60_000) expect(reconnect).toHaveBeenCalledTimes(8) expect(exhausted).toHaveBeenCalledOnce() recovery.update() expect(exhausted).toHaveBeenCalledOnce() await vi.advanceTimersByTimeAsync(60_000) expect(reconnect).toHaveBeenCalledTimes(8) expect(reconnect.mock.calls.map(([options]) => options)).toEqual( Array.from({ length: 8 }, () => preference === 'auto' ? { forceRelay: true } : {}), ) } })), prepare) }) it('cancels stale retries on lifecycle, identity and security transitions', async () => { await runScenarios(['background', 'disconnect', 'switch-host', 'reauth', 'refused', 'manual-connect', 'never-connected'] .map(action => ({ name: action, run: async () => { if (action === 'never-connected') { state.connection.phase = 'disconnected' recovery.update() } offline() if (action === 'background') recovery.setActive(false) if (action === 'disconnect') state.connection.phase = 'disconnected' if (action === 'switch-host') state.selectedDevice = { deviceId: 'host-2' } if (action === 'reauth') state.reauthRequired = true if (action === 'refused') state.connection.retryable = false if (action === 'manual-connect') state.connection.phase = 'connecting' recovery.update() if (action === 'never-connected') { // A first attempt that never established retries twice immediately // over Relay and then gives up instead of hanging. await vi.advanceTimersByTimeAsync(0) expect(reconnect).toHaveBeenCalledTimes(1) expect(reconnect).toHaveBeenLastCalledWith({ forceRelay: true }) await vi.advanceTimersByTimeAsync(1_000) expect(reconnect).toHaveBeenCalledTimes(2) await vi.advanceTimersByTimeAsync(300_000) expect(reconnect).toHaveBeenCalledTimes(2) expect(exhausted).toHaveBeenCalledOnce() return } await vi.advanceTimersByTimeAsync(30_000) expect(reconnect).not.toHaveBeenCalled() if (action === 'refused') expect(exhausted).toHaveBeenCalledOnce() } })), prepare) }) it('allows only one recovery flight and rearms after a healthy connection', async () => { let finish!: (value: boolean) => void reconnect.mockImplementationOnce(() => new Promise(resolve => { finish = resolve })) offline() await vi.advanceTimersByTimeAsync(0) recovery.update() await vi.advanceTimersByTimeAsync(60_000) expect(reconnect).toHaveBeenCalledOnce() state.connection = { phase: 'connected', stats: { mode: 'Relay' } } recovery.update() finish(true) await vi.advanceTimersByTimeAsync(0) offline() reconnect.mockImplementationOnce(async () => { throw new Error('unavailable') }) await vi.advanceTimersByTimeAsync(0) expect(reconnect).toHaveBeenLastCalledWith({}) await vi.advanceTimersByTimeAsync(1_000) expect(reconnect).toHaveBeenLastCalledWith({ forceRelay: true }) recovery.setActive(false) await vi.advanceTimersByTimeAsync(30_000) expect(reconnect).toHaveBeenCalledTimes(3) // Returning to the foreground re-arms immediately, even after the // previous cycle was on its way through the backoff ladder. recovery.setActive(true) await vi.advanceTimersByTimeAsync(0) expect(reconnect).toHaveBeenCalledTimes(4) }) it('skips the 0ms fast-retry and uses jittered exponential backoff when the Host or device is offline', async () => { const random = vi.spyOn(Math, 'random').mockReturnValue(0.5) try { for (const errorCode of ['HOST_OFFLINE', 'DEVICE_OFFLINE'] as const) { prepare() state = { ...state, connection: { phase: 'offline', stats: { mode: 'Disconnected' }, errorCode }, } recovery.update() // 0.5 -> 0.5 + 0.25 = 0.75 * [3000, 6000, 12000, 24000, 30000, 60000, 60000, 60000] const expectedDelays = [2_250, 4_500, 9_000, 18_000, 22_500, 45_000, 45_000, 45_000] for (let i = 0; i < expectedDelays.length; i++) { const delay = expectedDelays[i]! await vi.advanceTimersByTimeAsync(delay - 1) expect(reconnect).toHaveBeenCalledTimes(i) await vi.advanceTimersByTimeAsync(1) expect(reconnect).toHaveBeenCalledTimes(i + 1) } expect(exhausted).toHaveBeenCalledOnce() // After the 8-attempt ladder exhausts, a low-frequency 60s jittered probe (0.75 * 60_000 = 45_000ms) // continues while the Host remains offline, even if a probe transitions to another retryable // error (CONNECTION_FAILED -> 120_000ms probe), and automatically recovers once the Host returns. reconnect.mockImplementationOnce(async () => { state = { ...state, connection: { phase: 'offline', stats: { mode: 'Disconnected' }, errorCode: 'CONNECTION_FAILED' }, } recovery.update() return false }) await vi.advanceTimersByTimeAsync(44_999) expect(reconnect).toHaveBeenCalledTimes(8) await vi.advanceTimersByTimeAsync(1) expect(reconnect).toHaveBeenCalledTimes(9) reconnect.mockImplementationOnce(async () => { state = { ...state, connection: { phase: 'connected', stats: { mode: 'Relay' } }, } recovery.update() return true }) await vi.advanceTimersByTimeAsync(119_999) expect(reconnect).toHaveBeenCalledTimes(9) await vi.advanceTimersByTimeAsync(1) expect(reconnect).toHaveBeenCalledTimes(10) expect(state.connection.phase).toBe('connected') } } finally { random.mockRestore() } }) })