ds-harness-remote-fast/apps/android/tests/connection-recovery.test.ts

180 lines
7.7 KiB
TypeScript

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<ConstructorParameters<typeof ForegroundConnectionRecovery>[0]>
let state: RecoveryState
let recovery: ForegroundConnectionRecovery
let reconnect: ReturnType<typeof vi.fn<(options: { forceRelay?: boolean }) => Promise<boolean>>>
let exhausted: ReturnType<typeof vi.fn>
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()
}
})
})