Files
archived-orca/mobile/src/tasks/task-query-storage.test.tsx
Kelvin Amoaba 9bfa701b9c perf(mobile): keep task lists on the phone between launches (#39948)
* perf(mobile): keep task lists on the phone between launches

* test(mobile): type the stored task list setItems mock
2026-11-08 20:45:13 +00:00

178 lines
5.8 KiB
TypeScript

import { createElement, type Dispatch, type SetStateAction } from 'react'
import { QueryClient, QueryClientProvider, notifyManager } from '@tanstack/react-query'
import { act, create } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import type { OrcaQueryStoreBackend } from '../device-store/query-storage'
import { hostQueryKey } from '../query/host-query-key'
import { createHostQueryPersistence } from '../query/host-query-persistence'
import type { TaskItem } from './mobile-tasks-project-workspace-types'
import { readKeptTaskHydration } from './task-queries'
import { useTaskListCache } from './use-task-list-cache'
import {
firstPaintTaskKeys,
NO_TASK_INPUT,
TASKS_TARGET,
taskHydrationStorage,
taskLastListKey,
taskLastListStorage,
taskListKey,
taskListStorage
} from './task-query-storage'
vi.mock('react-native', () => ({ AppState: {} }))
notifyManager.setScheduler(queueMicrotask)
const HOST = 'host-a'
const SAVED_AT = 1_794_000_000_000
const params = { provider: 'linear', workspace: 'ws-1', teams: 'team-1', filter: 'assigned' }
const storedRow = {
key: 'linear:STA-12',
provider: 'linear',
title: 'Keep task lists between launches',
subtitle: 'STA-12',
status: 'In Progress',
updatedAt: '2026-11-07T10:00:00.000Z',
source: { id: 'issue-12', identifier: 'STA-12', title: 'Keep task lists between launches' }
}
function memoryStore(hostId: string) {
const rows = new Map<string, string>()
const backend: OrcaQueryStoreBackend = {
hostId,
read: async (keys) => ({
status: 'ok',
values: keys.map((storeKey) => rows.get(storeKey) ?? null)
}),
write: async (ops) => {
for (const op of ops) {
if (op.value === null) {
rows.delete(op.key)
} else {
rows.set(op.key, op.value)
}
}
return { written: true }
}
}
return { backend, rows }
}
// What one document leaves on disk for the next: each value as its read landed, then flushed.
async function storeFromEarlierLaunch(
store: ReturnType<typeof memoryStore>,
records: { queryKey: readonly unknown[]; persist: unknown; data: unknown }[]
) {
const earlier = new QueryClient()
const persistence = createHostQueryPersistence(earlier, store.backend)
for (const { queryKey, persist, data } of records) {
earlier.getQueryCache().build(earlier, { queryKey, meta: { persist } })
earlier.setQueryData(queryKey, data, { updatedAt: SAVED_AT })
}
await vi.runAllTimersAsync()
await persistence.flush()
}
async function relaunch(store: ReturnType<typeof memoryStore>) {
const relaunched = new QueryClient()
const persistence = createHostQueryPersistence(relaunched, store.backend)
const restoring = persistence.restore(firstPaintTaskKeys(HOST))
await vi.runAllTimersAsync()
await restoring
return relaunched
}
describe('Tasks lists kept on the phone', () => {
beforeEach(() => {
vi.useFakeTimers({ now: SAVED_AT + 60_000 })
})
afterEach(() => {
vi.useRealTimers()
})
it('draws the list a provider showed at the last launch before Tasks is ready, rows only', async () => {
const store = memoryStore(HOST)
await storeFromEarlierLaunch(store, [
{
queryKey: taskLastListKey(HOST, 'linear'),
persist: taskLastListStorage.persist,
data: params
},
{
queryKey: taskListKey(HOST, params),
persist: taskListStorage.persist,
data: { items: [storedRow] }
}
])
const relaunched = await relaunch(store)
const setItems = vi.fn<Dispatch<SetStateAction<TaskItem[]>>>()
const setError = vi.fn()
const shown: { rowsReadAt?: number | null } = {}
function Probe() {
shown.rowsReadAt = useTaskListCache({
hostId: HOST,
items: [],
jiraConnection: {
connected: false,
sites: [],
selection: null,
credentialError: null,
unavailableReason: null
},
provider: 'linear',
taskUiReady: false,
setItems,
setError,
setGithubPages: vi.fn(),
setGithubCurrentPage: vi.fn(),
setGithubRepoSources: vi.fn(),
setGithubSourceErrors: vi.fn(),
setGithubSourceFallbacks: vi.fn(),
setGithubCountedTotalPages: vi.fn(),
setLoading: vi.fn(),
setTaskListSettled: vi.fn()
}).rowsReadAt
return null
}
await act(async () => {
create(createElement(QueryClientProvider, { client: relaunched }, createElement(Probe)))
await vi.runAllTimersAsync()
})
expect(setItems).toHaveBeenCalledWith([storedRow])
expect(shown.rowsReadAt).toBe(SAVED_AT)
// A failed first read's error stays up over the stored rows.
expect(setError).not.toHaveBeenCalled()
})
it('keeps agent launch commands and hook trust out of the stored hydration', async () => {
const store = memoryStore(HOST)
await storeFromEarlierLaunch(store, [
{
queryKey: hostQueryKey(HOST, taskHydrationStorage.family, TASKS_TARGET, NO_TASK_INPUT),
persist: taskHydrationStorage.persist,
data: {
settings: {
visibleTaskProviders: ['github', 'linear'],
agentCmdOverrides: { claude: 'ANTHROPIC_API_KEY=sk-ant-secret claude' }
},
ui: {
taskResumeState: { linearPreset: 'assigned' },
trustedOrcaHooks: { 'repo-1': { setup: 'hash-trusted' } }
},
glabInstalled: false,
linearConnected: true
}
}
])
const kept = readKeptTaskHydration(await relaunch(store), HOST)
expect(kept.stored).toBe(true)
expect(kept.hydration).toEqual({
settings: { visibleTaskProviders: ['github', 'linear'] },
ui: { taskResumeState: { linearPreset: 'assigned' } },
glabInstalled: false,
linearConnected: true
})
})
})