:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import { act, renderHook } from '@testing-library/react-native'
import { AppState } from 'react-native'
import { ApiError } from '@/api/client'
import { getTask, getTaskRun, openTaskRunStream, type TaskRunApi } from '@/api/tasks'
import { useConnectivity } from '@/lib/connectivity'
import { deliverPermissionResponse } from './commands'
import { useHandoffStore } from './handoffStore'
import { visibleAnswer } from './liveReport'
import { HYDRATION_QUIET_MS } from './runHydration'
import { followRun, useTaskRun } from './useTaskRun'
jest.mock('@react-native-async-storage/async-storage', () =>
require('@react-native-async-storage/async-storage/jest/async-storage-mock')
)
jest.mock('expo-notifications', () => ({}))
jest.mock('./commands', () => ({ deliverPermissionResponse: jest.fn() }))
jest.mock('@/api/tasks', () => ({
getTask: jest.fn(),
getTaskRun: jest.fn(),
openTaskRunStream: jest.fn(),
}))
const TASK = 'task-lifecycle'
const REPORT = 'report-lifecycle'
const RUN: TaskRunApi = {
id: 'run-lifecycle',
task: TASK,
status: 'in_progress',
stage: null,
branch: null,
error_message: null,
output: null,
completed_at: null,
}
function endedStream(): Response {
let sent = false
return {
body: {
getReader: () => ({
read: async () => {
if (sent) {
return { done: true }
}
sent = true
return { value: new TextEncoder().encode('event: stream-end\ndata: {}\n\n'), done: false }
},
cancel: async () => undefined,
}),
},
} as unknown as Response
}
function controlledStream(): { response: Response; send: (text: string) => void; fail: () => void; close: () => void } {
type Read = { value?: Uint8Array; done: boolean }
const queued: (Read | Error)[] = []
let waiting: { resolve: (read: Read) => void; reject: (error: Error) => void } | undefined
const deliver = (next: Read | Error): void => {
if (waiting) {
const target = waiting
waiting = undefined
if (next instanceof Error) {
target.reject(next)
} else {
target.resolve(next)
}
} else {
queued.push(next)
}
}
return {
response: {
body: {
getReader: () => ({
read: () =>
new Promise<Read>((resolve, reject) => {
const next = queued.shift()
if (next instanceof Error) {
reject(next)
} else if (next) {
resolve(next)
} else {
waiting = { resolve, reject }
}
}),
cancel: async () => {
deliver({ done: true })
},
}),
},
} as unknown as Response,
send: (text) => deliver({ value: new TextEncoder().encode(text), done: false }),
fail: () => deliver(new Error('connection dropped')),
close: () => deliver({ done: true }),
}
}
function event(id: string, data: unknown): string {
return `id: ${id}\ndata: ${JSON.stringify(data)}\n\n`
}
function toolFrame(title: string, eventId: string): unknown {
return {
event_id: eventId,
type: 'notification',
notification: {
method: 'session/update',
params: { update: { sessionUpdate: 'tool_call', toolCallId: eventId, title } },
},
}
}
function turnEnd(eventId: string): unknown {
return { event_id: eventId, type: 'notification', notification: { method: '_posthog/turn_complete', params: {} } }
}
const HISTORICAL_PERMISSION = {
event_id: 'permission-history',
type: 'permission_request',
requestId: 'history-request',
options: [{ optionId: 'allow', kind: 'allow_once', name: 'Yes' }],
toolCall: {
toolCallId: 'permission-tool',
title: 'Run tests',
kind: 'execute',
_meta: { claudeCode: { toolName: 'Bash' } },
},
}
describe('report run connection lifecycle', () => {
beforeEach(() => {
jest.useFakeTimers()
jest.clearAllMocks()
AppState.currentState = 'active'
jest.spyOn(AppState, 'addEventListener').mockReturnValue({ remove: jest.fn() })
useConnectivity.setState({ status: 'unknown' })
useHandoffStore.setState({ reports: {} })
jest.mocked(getTask).mockResolvedValue({ id: TASK, title: '', signal_report: REPORT, latest_run: RUN })
jest.mocked(getTaskRun).mockResolvedValue(RUN)
})
afterEach(() => {
jest.useRealTimers()
})
test('an offline report waits, resumes with its cursor, and never resends commands', async () => {
useConnectivity.setState({ status: 'offline' })
const first = controlledStream()
const second = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValueOnce(first.response).mockResolvedValueOnce(second.response)
const { unmount } = renderHook(() => useTaskRun(REPORT, { taskId: TASK, runId: RUN.id }, true))
try {
await act(async () => {})
expect(openTaskRunStream).not.toHaveBeenCalled()
await act(async () => {
useConnectivity.setState({ status: 'connected' })
})
await act(async () => {
first.send(event('network-100-0', toolFrame('Read source', 'network-event')))
first.send('event: keepalive\ndata: {}\n\n')
})
await act(async () => {
useConnectivity.setState({ status: 'offline' })
})
expect(jest.mocked(openTaskRunStream).mock.calls[0]?.[2]?.signal?.aborted).toBe(true)
await act(async () => {
useConnectivity.setState({ status: 'connected' })
})
expect(openTaskRunStream).toHaveBeenCalledTimes(2)
expect(jest.mocked(openTaskRunStream).mock.calls[1]?.[2]?.lastEventId).toBe('network-100-0')
expect(deliverPermissionResponse).not.toHaveBeenCalled()
} finally {
unmount()
}
})
test.each([401, 403, 404, 'completed'] as const)(
'link recovery leaves a %s report stream stopped',
async (outcome) => {
if (outcome === 'completed') jest.mocked(getTaskRun).mockResolvedValue({ ...RUN, status: 'completed' })
else jest.mocked(openTaskRunStream).mockRejectedValueOnce(new ApiError(outcome, undefined))
const { unmount } = renderHook(() => useTaskRun(REPORT, { taskId: TASK, runId: RUN.id }, true))
try {
await act(async () => {})
const attempts = jest.mocked(getTaskRun).mock.calls.length
await act(async () => {
useConnectivity.setState({ status: 'offline' })
})
await act(async () => {
useConnectivity.setState({ status: 'connected' })
})
expect(getTaskRun).toHaveBeenCalledTimes(attempts)
} finally {
unmount()
}
}
)
test('shows reconnecting while admission retries, then unavailable when access is refused', async () => {
jest.mocked(openTaskRunStream)
.mockRejectedValueOnce(new Error('offline'))
.mockRejectedValueOnce(new ApiError(403, {}))
const followed = followRun({
reportId: REPORT,
taskId: TASK,
runId: RUN.id,
signal: new AbortController().signal,
})
await jest.advanceTimersByTimeAsync(0)
expect(useHandoffStore.getState().reports[REPORT]?.live?.connection).toBe('reconnecting')
await jest.advanceTimersByTimeAsync(2000)
await followed
expect(useHandoffStore.getState().reports[REPORT]?.live?.connection).toBe('unavailable')
})
test('uses a newly resumed latest run and settles completed runs without a disconnect warning', async () => {
const resumed = { ...RUN, id: 'run-resumed', status: 'completed' as const }
jest.mocked(getTask).mockResolvedValue({ id: TASK, title: '', signal_report: REPORT, latest_run: resumed })
const snapshots: string[] = []
await followRun({
reportId: REPORT,
taskId: TASK,
runId: RUN.id,
signal: new AbortController().signal,
onTaskSnapshot: (task) => snapshots.push(task.latest_run?.id ?? ''),
})
expect(snapshots).toEqual(['run-resumed'])
expect(useHandoffStore.getState().reports[REPORT]?.live).toMatchObject({
runId: 'run-resumed',
status: 'completed',
})
expect(useHandoffStore.getState().reports[REPORT]?.live?.connection).toBeUndefined()
expect(openTaskRunStream).not.toHaveBeenCalled()
})
test('a late canceled bootstrap cannot replace the task now being followed', async () => {
let finish!: (task: Awaited<ReturnType<typeof getTask>>) => void
jest.mocked(getTask).mockImplementationOnce(
() =>
new Promise((resolve) => {
finish = resolve
})
)
const controller = new AbortController()
const cacheSnapshot = jest.fn()
const followed = followRun({
reportId: REPORT,
taskId: TASK,
runId: RUN.id,
signal: controller.signal,
onTaskSnapshot: cacheSnapshot,
})
controller.abort()
useHandoffStore.getState().setAnswer(REPORT, {
questionId: 'old-question',
question: { id: 'old-question', question: 'Continue?', options: [] },
text: 'Yes',
delivery: 'delivered',
activity: 0,
})
useHandoffStore.getState().setPartial(REPORT, { requestId: 'old-question', labels: ['Yes'] })
useHandoffStore.getState().setNotice(REPORT, 'Old notice')
const newer = { ...RUN, id: 'run-next', task: 'task-next' }
useHandoffStore.getState().applySnapshot(REPORT, newer.task, newer)
finish({ id: TASK, title: '', signal_report: REPORT, latest_run: RUN })
await followed
expect(useHandoffStore.getState().reports[REPORT]?.live?.runId).toBe('run-next')
expect(useHandoffStore.getState().reports[REPORT]).toMatchObject({
answer: undefined,
partial: undefined,
notice: undefined,
})
expect(cacheSnapshot).not.toHaveBeenCalled()
expect(openTaskRunStream).not.toHaveBeenCalled()
})
test('a nonterminal stream end stops claiming execution and refreshes the task snapshot', async () => {
jest.mocked(openTaskRunStream).mockResolvedValue(endedStream())
const refresh = jest.fn()
await followRun({
reportId: REPORT,
taskId: TASK,
runId: RUN.id,
signal: new AbortController().signal,
onRefresh: refresh,
})
expect(useHandoffStore.getState().reports[REPORT]?.live).toMatchObject({ phase: 'unknown' })
expect(useHandoffStore.getState().reports[REPORT]?.live?.connection).toBeUndefined()
expect(refresh).toHaveBeenCalledTimes(1)
})
test('slow durable history stays private, settles once, and new live activity updates immediately', async () => {
const stream = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValue(stream.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
const publications: string[] = []
const unsubscribe = useHandoffStore.subscribe((state) => {
const live = state.reports[REPORT]?.live
if (live) {
publications.push(`${live.phase}:${live.toolTitle ?? ''}:${live.pending?.record.requestId ?? ''}`)
}
})
try {
for (const [index, frame] of [
toolFrame('Read old.ts', 'old-tool'),
HISTORICAL_PERMISSION,
turnEnd('old-complete'),
].entries()) {
stream.send(event(`log-${index}`, frame))
await jest.advanceTimersByTimeAsync(HYDRATION_QUIET_MS * 2)
expect(publications).toEqual([])
}
stream.send(event('1900000000000-0', { type: 'task_run_state', run_id: RUN.id, status: 'in_progress' }))
await jest.advanceTimersByTimeAsync(HYDRATION_QUIET_MS)
expect(publications).toEqual(['idle::'])
expect(deliverPermissionResponse).not.toHaveBeenCalled()
stream.send(event('1900000000001-0', toolFrame('Edit new.ts', 'new-tool')))
await jest.advanceTimersByTimeAsync(0)
expect(publications.at(-1)).toBe('working:Editing new.ts:')
} finally {
unsubscribe()
controller.abort()
await followed
}
})
test('rotation keeps private state and cursor together, and abort discards unpublished replay on reopen', async () => {
const first = controlledStream()
const rotated = controlledStream()
const reopened = controlledStream()
jest.mocked(openTaskRunStream)
.mockResolvedValueOnce(first.response)
.mockResolvedValueOnce(rotated.response)
.mockResolvedValueOnce(reopened.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
first.send(event('log-0', HISTORICAL_PERMISSION))
await jest.advanceTimersByTimeAsync(HYDRATION_QUIET_MS * 2)
first.send('event: end\ndata: {"type":"rotated"}\n\n')
await jest.advanceTimersByTimeAsync(0)
expect(openTaskRunStream).toHaveBeenLastCalledWith(
TASK,
RUN.id,
expect.objectContaining({ lastEventId: 'log-0' })
)
expect(useHandoffStore.getState().reports[REPORT]?.live?.pending).toBeUndefined()
controller.abort()
await followed
const nextController = new AbortController()
const next = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: nextController.signal })
await jest.advanceTimersByTimeAsync(0)
expect(openTaskRunStream).toHaveBeenLastCalledWith(
TASK,
RUN.id,
expect.objectContaining({ lastEventId: undefined })
)
reopened.send(event('log-0', HISTORICAL_PERMISSION))
reopened.send('event: keepalive\ndata: {}\n\n')
await jest.advanceTimersByTimeAsync(0)
expect(useHandoffStore.getState().reports[REPORT]?.live?.pending?.record.requestId).toBe('history-request')
expect(deliverPermissionResponse).not.toHaveBeenCalled()
nextController.abort()
await next
})
test('an answer sent during catchup stays delivered and its handled request cannot return', async () => {
useHandoffStore.getState().applySnapshot(REPORT, TASK, RUN)
const stream = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValue(stream.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
stream.send(event('log-0', HISTORICAL_PERMISSION))
await jest.advanceTimersByTimeAsync(0)
useHandoffStore.getState().markHandled(REPORT, 'history-request')
useHandoffStore.getState().setAnswer(REPORT, {
questionId: 'history-request',
question: { id: 'history-request', question: 'Run tests?', options: [] },
text: 'Yes',
delivery: 'delivered',
activity: 0,
})
stream.send('event: keepalive\ndata: {}\n\n')
await jest.advanceTimersByTimeAsync(0)
const entry = useHandoffStore.getState().reports[REPORT]
expect(entry?.live?.pending).toBeUndefined()
expect(visibleAnswer(entry, undefined)?.text).toBe('Yes')
controller.abort()
await followed
})
test('reconnect catches missed activity and uses the fresh snapshot without retaining an old answer', async () => {
const first = controlledStream()
const next = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValueOnce(first.response).mockResolvedValueOnce(next.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
first.send(event('1900000000010-0', turnEnd('prior-turn')))
await jest.advanceTimersByTimeAsync(HYDRATION_QUIET_MS)
const activity = useHandoffStore.getState().reports[REPORT]?.live?.activity ?? 0
useHandoffStore.getState().setAnswer(REPORT, {
questionId: 'old-answer',
question: { id: 'old-answer', question: 'Continue?', options: [] },
text: 'Yes',
delivery: 'delivered',
activity,
})
jest.mocked(getTaskRun).mockResolvedValue({
...RUN,
stage: 'Fresh snapshot',
output: { pr_url: 'https://github.com/example/repo/pull/12' },
})
first.fail()
await jest.advanceTimersByTimeAsync(2000)
next.send(event('1900000000011-0', toolFrame('Edit resumed.ts', 'resumed-tool')))
next.send(event('1900000000012-0', turnEnd('resumed-turn')))
await jest.advanceTimersByTimeAsync(HYDRATION_QUIET_MS)
const entry = useHandoffStore.getState().reports[REPORT]
expect(entry?.live).toMatchObject({
phase: 'idle',
turnEnded: true,
prUrl: 'https://github.com/example/repo/pull/12',
})
expect(visibleAnswer(entry, undefined)).toBeUndefined()
controller.abort()
await followed
})
test('unmarked EOF keeps incomplete history private while reconnecting', async () => {
const first = controlledStream()
const second = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValueOnce(first.response).mockResolvedValueOnce(second.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
first.send(event('log-0', HISTORICAL_PERMISSION))
first.close()
await jest.advanceTimersByTimeAsync(0)
expect(useHandoffStore.getState().reports[REPORT]?.live?.pending).toBeUndefined()
expect(useHandoffStore.getState().reports[REPORT]?.live?.connection).toBe('reconnecting')
await jest.advanceTimersByTimeAsync(2000)
second.send(event('log-1', turnEnd('eof-complete')))
second.send('event: keepalive\ndata: {}\n\n')
await jest.advanceTimersByTimeAsync(0)
expect(useHandoffStore.getState().reports[REPORT]?.live?.turnEnded).toBe(true)
expect(useHandoffStore.getState().reports[REPORT]?.live?.pending).toBeUndefined()
controller.abort()
await followed
})
test('a terminal snapshot preserves every PR discovered in private history', async () => {
const stream = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValue(stream.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
const first = 'https://github.com/example/repo/pull/1'
const second = 'https://github.com/example/repo/pull/2'
stream.send(event('log-0', { type: 'task_run_state', run_id: RUN.id, output: { pr_urls: [first, second] } }))
jest.mocked(getTaskRun).mockResolvedValue({ ...RUN, status: 'completed', output: { pr_url: first } })
stream.fail()
await followed
expect(useHandoffStore.getState().reports[REPORT]?.live).toMatchObject({
status: 'completed',
prUrls: [first, second],
})
expect(useHandoffStore.getState().reports[REPORT]?.live?.connection).toBeUndefined()
})
test('a replaced task stops the old follower before a final snapshot can overwrite its successor', async () => {
const stream = controlledStream()
jest.mocked(openTaskRunStream).mockResolvedValue(stream.response)
const controller = new AbortController()
const followed = followRun({ reportId: REPORT, taskId: TASK, runId: RUN.id, signal: controller.signal })
await jest.advanceTimersByTimeAsync(0)
const nextRun = { ...RUN, task: 'replacement-task', id: 'replacement-run' }
useHandoffStore.getState().applySnapshot(REPORT, nextRun.task, nextRun)
stream.send(event('1900000000020-0', toolFrame('Edit replaced.ts', 'replaced-tool')))
await followed
expect(useHandoffStore.getState().reports[REPORT]?.live).toMatchObject({
taskId: nextRun.task,
runId: nextRun.id,
})
expect(getTaskRun).not.toHaveBeenCalled()
})
})