diff --git a/apps/android/tests/connection-recovery.test.ts b/apps/android/tests/connection-recovery.test.ts new file mode 100644 index 0000000..ef4b6cf --- /dev/null +++ b/apps/android/tests/connection-recovery.test.ts @@ -0,0 +1,179 @@ +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() + } + }) +})