ds-harness-remote-fast/apps/android/tests/state-operation-isolation.t...

394 lines
24 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
import type { AppState, StoreAccess } from '../src/state/store-state'
import type { AndroidRemoteRuntime } from '../src/services/remote-runtime'
import type { WorkspaceView } from '../src/types'
const mocks = vi.hoisted(() => ({
authenticate: vi.fn(), reconcile: vi.fn(), createContext: vi.fn(), signInWith: vi.fn(),
storage: Object.fromEntries([
'loadTrustedHosts', 'forgetHost', 'clearCodexPermissionPresets', 'clearDeviceCredentials',
'saveServerConfig', 'clearLocalData', 'loadOrCreateIdentity', 'saveLanguagePreference',
'saveCompactHistory', 'saveThemePreference', 'saveTypographyDensity', 'loadTypographyDensity', 'saveActivityDockMode', 'loadActivityDockMode', 'saveStatusBarVisible', 'saveDefaultPermissionPreset', 'saveFavoriteWorkspaces',
'saveRecentWorkspaces', 'loadCodexPermissionPresets', 'clearLastConnectedDeviceId',
].map(name => [name, vi.fn()])),
createCodex: vi.fn(), loadCodex: vi.fn(), loadAgy: vi.fn(), loadPi: vi.fn(), loadOpencode: vi.fn(), loadClaude: vi.fn(), loadHermes: vi.fn(),
}))
vi.mock('expo-haptics', () => ({ notificationAsync: vi.fn(), NotificationFeedbackType: { Success: 'success' } }))
vi.mock('../src/services/storage', () => mocks.storage)
vi.mock('../src/services/server-session', () => ({ serverSession: { authenticate: mocks.authenticate } }))
vi.mock('../src/services/device-directory', () => ({ reconcileTrustedDevices: mocks.reconcile }))
vi.mock('../src/services/login', () => ({
loginFlow: { createContext: mocks.createContext, signInWith: mocks.signInWith },
passwordLoginChannel: { busyAction: 'login' },
}))
vi.mock('../src/services/rpc-id', () => ({ createNativeRpcId: () => 'test-rpc' }))
vi.mock('../src/services/codex', async importOriginal => ({
...await importOriginal<typeof import('../src/services/codex')>(),
createCodexWorkspace: mocks.createCodex, loadCodexCatalog: mocks.loadCodex,
}))
vi.mock('../src/services/antigravity', async importOriginal => ({
...await importOriginal<typeof import('../src/services/antigravity')>(), loadAntigravityCatalog: mocks.loadAgy,
}))
vi.mock('../src/services/claude', async importOriginal => ({
...await importOriginal<typeof import('../src/services/claude')>(), loadClaudeCatalog: mocks.loadClaude,
}))
vi.mock('../src/services/pi', async importOriginal => ({
...await importOriginal<typeof import('../src/services/pi')>(), loadPiCatalog: mocks.loadPi,
}))
vi.mock('../src/services/hermes', async importOriginal => ({
...await importOriginal<typeof import('../src/services/hermes')>(), loadHermesCatalog: mocks.loadHermes,
}))
vi.mock('../src/services/opencode', async importOriginal => ({
...await importOriginal<typeof import('../src/services/opencode')>(), loadOpencodeCatalog: mocks.loadOpencode,
}))
import { RemoteServerApi } from '../src/services/api'
import { createAccountActions } from '../src/state/account-actions'
import { createWorkspaceActions } from '../src/state/workspace-actions'
import { initialData } from '../src/state/store-state'
function deferred<T>() {
let resolve!: (value: T) => void
let reject!: (reason: unknown) => void
const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no })
return { promise, resolve, reject }
}
const authError = () => Object.assign(new Error('old authorization'), { code: 'AUTH_INVALID' })
const workspace = (id: string, backend: WorkspaceView['backend'] = 'harness'): WorkspaceView => ({
workspaceId: id, title: id, path: `/${id}`, backend, sessionIds: [], createdAt: '', updatedAt: '',
})
function storeFixture() {
let state = {
...initialData(), config: { baseUrl: 'https://example.invalid', account: 'A' },
identity: { deviceId: 'phone' }, languagePreference: 'system', themePreference: 'system',
statusBarVisible: true, defaultPermissionPreset: 'default', disconnect: vi.fn(async () => undefined),
} as unknown as AppState
const access: StoreAccess = {
get: () => state,
set: partial => { state = { ...state, ...typeof partial === 'function' ? partial(state) : partial } },
}
return access
}
function accountFixture() {
const store = storeFixture()
store.set(createAccountActions(store))
return store
}
function prepare() {
vi.resetAllMocks()
mocks.storage.loadTrustedHosts!.mockResolvedValue([])
mocks.storage.loadCodexPermissionPresets!.mockResolvedValue({})
mocks.storage.loadOrCreateIdentity!.mockResolvedValue({ deviceId: 'new-phone' })
mocks.authenticate.mockResolvedValue({ api: { removeSelf: vi.fn() } })
mocks.reconcile.mockResolvedValue({ devices: [], missingTrustedDeviceIds: [] })
mocks.createContext.mockResolvedValue({ baseUrl: 'https://example.invalid' })
mocks.signInWith.mockResolvedValue({ account: 'B', loginMethod: 'password' })
}
beforeEach(prepare)
afterEach(() => vi.restoreAllMocks())
describe('account directory operation isolation', () => {
it('saves a validated server and isolates old credentials while rejecting failed switches', async () => {
await runScenarios(['new-server', 'same-server', 'unavailable', 'invalid'].map(name => ({
name,
run: async () => {
prepare()
const health = vi.spyOn(RemoteServerApi.prototype, 'health').mockResolvedValue(undefined)
if (name === 'unavailable') health.mockRejectedValue(new Error('unavailable'))
const store = accountFixture()
const previous = store.get().config
store.set({ pendingOAuthBaseUrl: previous!.baseUrl, pendingOAuthLoginMethod: 'google-oauth' })
mocks.storage.loadTrustedHosts!.mockResolvedValue([{ deviceId: 'old-host' }])
const target = name === 'same-server' ? previous!.baseUrl : name === 'invalid' ? 'http://public.example.com' : 'https://new.example.com/'
const saved = await store.get().selectServer(target)
if (name === 'new-server') {
expect(saved).toBe('https://new.example.com')
expect(mocks.storage.saveServerConfig).toHaveBeenCalledWith({ baseUrl: saved })
expect(store.get().disconnect).toHaveBeenCalledOnce()
expect(mocks.storage.clearDeviceCredentials).toHaveBeenCalledOnce()
expect(mocks.storage.forgetHost).toHaveBeenCalledWith('old-host')
expect(mocks.storage.clearCodexPermissionPresets).toHaveBeenCalledWith('old-host')
expect(store.get()).toMatchObject({ config: { baseUrl: saved }, reauthRequired: true, devices: [] })
expect(store.get().pendingOAuthBaseUrl).toBeUndefined()
expect(store.get().pendingOAuthLoginMethod).toBeUndefined()
expect(store.get().account).toBeUndefined()
} else {
expect(saved).toBe(name === 'same-server' ? previous!.baseUrl : undefined)
expect(store.get().config).toBe(previous)
expect(store.get().disconnect).not.toHaveBeenCalled()
expect(mocks.storage.clearDeviceCredentials).not.toHaveBeenCalled()
expect(mocks.storage.saveServerConfig).not.toHaveBeenCalled()
}
health.mockRestore()
},
})))
})
it('ignores old directory success and authentication failures after account or identity replacement', async () => {
await runScenarios(['config', 'identity'].flatMap(change => ['success', 'auth-error', 'network-error'].map(outcome => ({
name: `${change}/${outcome}`,
run: async () => {
const store = accountFixture()
const response = deferred<any>()
mocks.reconcile.mockReturnValueOnce(response.promise)
const pending = store.get().refreshDevices()
await vi.waitFor(() => expect(mocks.reconcile).toHaveBeenCalledOnce())
store.set({ [change]: change === 'config' ? { baseUrl: 'https://new.invalid', account: 'B' } : { deviceId: 'replacement' } } as Partial<AppState>)
store.set({ devices: [{ deviceId: 'B' }] as AppState['devices'], error: 'new error', refreshing: true, busyAction: 'new action' })
const expected = store.get()
if (outcome === 'success') response.resolve({ devices: [{ deviceId: 'A' }], missingTrustedDeviceIds: ['B'] })
else response.reject(outcome === 'auth-error' ? authError() : new Error('old network failure'))
await pending
expect(store.get()).toEqual(expected)
expect(mocks.storage.forgetHost).not.toHaveBeenCalled()
expect(mocks.storage.clearCodexPermissionPresets).not.toHaveBeenCalled()
expect(mocks.storage.clearDeviceCredentials).not.toHaveBeenCalled()
expect(store.get().disconnect).not.toHaveBeenCalled()
},
}))), prepare)
})
it('lets only the newest directory refresh publish or trigger reauthorization', async () => {
await runScenarios(['success', 'auth-error'].map(outcome => ({ name: outcome, run: async () => {
const store = accountFixture()
const old = deferred<any>()
mocks.reconcile.mockReturnValueOnce(old.promise)
const pending = store.get().refreshDevices()
await vi.waitFor(() => expect(mocks.reconcile).toHaveBeenCalledOnce())
mocks.reconcile.mockResolvedValueOnce({ devices: [{ deviceId: 'latest' }], missingTrustedDeviceIds: [] })
await store.get().refreshDevices()
if (outcome === 'success') old.resolve({ devices: [], missingTrustedDeviceIds: ['latest'] })
else old.reject(authError())
await pending
expect(store.get().devices).toEqual([{ deviceId: 'latest' }])
expect(store.get().refreshing).toBe(false)
expect(store.get().reauthRequired).toBe(false)
expect(mocks.storage.forgetHost).not.toHaveBeenCalled()
} })), prepare)
})
it('invalidates refresh immediately and drains credential writes or cleanup before account transitions', async () => {
await runScenarios(['authenticate', 'cleanup'].flatMap(stage => ['login', 'sign-out', 'reset', 'reauth'].map(transition => ({
name: `${stage}/${transition}`,
run: async () => {
const store = accountFixture()
const gate = deferred<any>()
if (stage === 'authenticate') mocks.authenticate.mockReturnValueOnce(gate.promise)
else {
mocks.reconcile.mockResolvedValueOnce({ devices: [{ deviceId: 'old' }], missingTrustedDeviceIds: ['removed-1', 'removed-2'] })
mocks.storage.forgetHost!.mockReturnValueOnce(gate.promise)
}
const refreshing = store.get().refreshDevices()
await vi.waitFor(() => expect(stage === 'authenticate' ? mocks.authenticate : mocks.storage.forgetHost).toHaveBeenCalledOnce())
const changing = transition === 'login' ? store.get().configureServer('https://example.invalid', 'B', 'password')
: transition === 'sign-out' ? store.get().signOut()
: transition === 'reset' ? store.get().resetLocalData() : store.get().requireReauth('reauth')
expect(store.get().refreshing).toBe(false)
await Promise.resolve()
expect(mocks.signInWith).not.toHaveBeenCalled()
expect(mocks.storage.clearLocalData).not.toHaveBeenCalled()
expect(mocks.storage.clearDeviceCredentials).not.toHaveBeenCalled()
gate.resolve({ api: {} })
await Promise.all([refreshing, changing])
expect(mocks.storage.clearCodexPermissionPresets).not.toHaveBeenCalled()
expect(mocks.storage.forgetHost).toHaveBeenCalledTimes(stage === 'cleanup' ? 1 : 0)
expect(store.get().devices).toEqual([])
expect(store.get().account).toBe(transition === 'login' ? 'B' : undefined)
expect(store.get().reauthRequired).toBe(transition === 'reauth')
},
}))), prepare)
})
it('still removes every revoked pin sequentially and handles current authorization failures', async () => {
await runScenarios(['cleanup', 'auth-error', 'key-mismatch', 'lookup-failed-pinned', 'preserve-unrelated-error'].map(name => ({ name, run: async () => {
const store = accountFixture()
if (name === 'auth-error') mocks.reconcile.mockRejectedValueOnce(authError())
else if (name === 'key-mismatch') mocks.reconcile.mockResolvedValueOnce({ devices: [], missingTrustedDeviceIds: [], keyMismatchDeviceIds: ['host-1'], lookupFailedDeviceIds: [] })
else if (name === 'lookup-failed-pinned') mocks.reconcile.mockResolvedValueOnce({ devices: [{ deviceId: 'host-1' }], missingTrustedDeviceIds: [], keyMismatchDeviceIds: [], lookupFailedDeviceIds: ['host-1'], lookupError: new Error('descriptor timeout') })
else if (name === 'preserve-unrelated-error') {
store.set({ error: 'unrelated session error' })
mocks.reconcile.mockResolvedValueOnce({ devices: [{ deviceId: 'valid' }], missingTrustedDeviceIds: [] })
}
else mocks.reconcile.mockResolvedValueOnce({ devices: [{ deviceId: 'valid' }], missingTrustedDeviceIds: ['one', 'two'] })
await store.get().refreshDevices()
expect(store.get().refreshing).toBe(false)
if (name === 'auth-error') {
expect(store.get().reauthRequired).toBe(true)
expect(mocks.storage.clearDeviceCredentials).toHaveBeenCalledOnce()
expect(store.get().disconnect).toHaveBeenCalledOnce()
} else if (name === 'key-mismatch') {
expect(store.get().devices).toEqual([])
expect(store.get().error).toBeTruthy()
mocks.reconcile.mockResolvedValueOnce({ devices: [{ deviceId: 'host-1' }], missingTrustedDeviceIds: [] })
await store.get().refreshDevices()
expect(store.get().error).toBeUndefined()
} else if (name === 'lookup-failed-pinned') {
expect(store.get().devices).toEqual([{ deviceId: 'host-1' }])
expect(store.get().error).toBeTruthy()
} else if (name === 'preserve-unrelated-error') {
expect(store.get().devices).toEqual([{ deviceId: 'valid' }])
expect(store.get().error).toBe('unrelated session error')
} else {
expect(store.get().devices).toEqual([{ deviceId: 'valid' }])
expect(store.get().error).toBeUndefined()
expect(mocks.storage.forgetHost!.mock.calls).toEqual([['one'], ['two']])
expect(mocks.storage.clearCodexPermissionPresets!.mock.calls).toEqual([['one'], ['two']])
expect(mocks.storage.clearCodexPermissionPresets!.mock.invocationCallOrder[0]).toBeLessThan(mocks.storage.forgetHost!.mock.invocationCallOrder[1]!)
}
} })), prepare)
})
})
function workspaceFixture() {
const store = storeFixture()
let generation = 1
let backend: object = {}
const proxy = {
workspaceCreate: vi.fn(), workspaceRename: vi.fn(), workspaceDelete: vi.fn(), workspaceInsertBefore: vi.fn(),
workspaceList: vi.fn(async () => ({ items: [], archivedSessionIds: [] })), sessionList: vi.fn(async () => []), hostListDirectory: vi.fn(),
}
const runtime = {
refreshBackends: vi.fn(), requireProxy: () => backend === proxy ? proxy : backend,
hasCodex: () => false, hasCursor: () => true, hasAntigravity: () => true, hasPi: () => true, hasOpencode: () => true, hasClaude: () => true, hasHermes: () => true,
requireCodex: () => backend, requireAntigravity: () => backend, requirePi: () => backend, requireOpencode: () => backend, requireClaude: () => backend, requireHermes: () => backend,
}
backend = proxy
const close = vi.fn(async () => undefined)
store.set({ connection: { phase: 'connected', stats: { mode: 'Relay', connected: true } },
selectedDevice: { deviceId: 'host-A' } as AppState['selectedDevice'], workspaces: [workspace('existing')] })
store.set(createWorkspaceActions({ ...store, connection: runtime as unknown as AndroidRemoteRuntime,
getConnectionGeneration: () => generation, closeActiveCursorStream: close }))
return { ...store, proxy, close, switchHost: () => { ++generation }, replaceBackend: () => { backend = {} } }
}
const backendCases = ['harness', 'codex', 'antigravity', 'pi', 'opencode'] as const
function createRequest(fixture: ReturnType<typeof workspaceFixture>, backend: typeof backendCases[number]) {
return backend === 'harness' ? fixture.proxy.workspaceCreate : backend === 'codex' ? mocks.createCodex
: backend === 'antigravity' ? mocks.loadAgy : backend === 'pi' ? mocks.loadPi : mocks.loadOpencode
}
function createResponse(backend: typeof backendCases[number], id: string) {
const value = workspace(id, backend)
return backend === 'harness' ? { workspace: value } : backend === 'codex' ? value : { workspaces: [value], sessions: [] }
}
describe('workspace operation isolation', () => {
it('loads only the requested backend and keeps other catalogs and failures isolated', async () => {
const loaders = { codex: mocks.loadCodex, antigravity: mocks.loadAgy, pi: mocks.loadPi, opencode: mocks.loadOpencode, claude: mocks.loadClaude, hermes: mocks.loadHermes }
await runScenarios((['harness', 'codex', 'cursor', 'antigravity', 'pi', 'opencode', 'claude', 'hermes'] as const).flatMap(backend =>
['success', 'error'].map(outcome => ({ name: `${backend}/${outcome}`, run: async () => {
const fixture = workspaceFixture()
const other = workspace('other', backend === 'codex' ? 'harness' : 'codex')
fixture.set({ workspaces: [other], error: 'unrelated error' })
const loader = backend === 'harness' ? fixture.proxy.workspaceList : backend === 'cursor' ? undefined : loaders[backend]
if (outcome === 'error') loader?.mockRejectedValueOnce(new Error('category unavailable'))
else loader?.mockResolvedValueOnce(backend === 'harness'
? { items: [workspace('loaded')], archivedSessionIds: [] }
: { workspaces: [workspace('loaded', backend)], sessions: [] })
await fixture.get().refreshWorkspaces(backend)
expect(fixture.proxy.workspaceList).toHaveBeenCalledTimes(backend === 'harness' ? 1 : 0)
for (const [name, load] of Object.entries(loaders)) expect(load).toHaveBeenCalledTimes(backend === name ? 1 : 0)
expect(fixture.get().workspaces).toContainEqual(other)
expect(fixture.get().error).toBe('unrelated error')
if (outcome === 'success' && backend !== 'harness' && backend !== 'codex' && backend !== 'cursor') {
const flag = { antigravity: 'antigravityAvailable', pi: 'piAvailable', opencode: 'opencodeAvailable',
claude: 'claudeAvailable', hermes: 'hermesAvailable' }[backend]
expect(fixture.get()[flag as 'hermesAvailable']).toBe(true)
}
expect(fixture.get().workspaceCatalog).toEqual({ backend, loading: false,
...(outcome === 'error' && backend !== 'cursor' ? { error: 'category unavailable' } : {}) })
} }))), prepare)
})
it('ignores catalog results and failures after another category opens', async () => {
await runScenarios(['success', 'error'].map(outcome => ({ name: outcome, run: async () => {
const fixture = workspaceFixture()
const old = deferred<any>()
mocks.loadOpencode.mockReturnValueOnce(old.promise)
const pending = fixture.get().refreshWorkspaces('opencode')
await vi.waitFor(() => expect(mocks.loadOpencode).toHaveBeenCalledOnce())
mocks.loadCodex.mockResolvedValueOnce({ workspaces: [workspace('selected', 'codex')], sessions: [] })
await fixture.get().refreshWorkspaces('codex')
const expected = fixture.get()
if (outcome === 'success') old.resolve({ workspaces: [workspace('retired', 'opencode')], sessions: [] })
else old.reject(new Error('retired category failure'))
await pending
expect(fixture.get()).toEqual(expected)
expect(fixture.get().workspaceCatalog).toEqual({ backend: 'codex', loading: false })
} })), prepare)
})
it('rejects stale creation success/errors for every asynchronous backend and preserves successor state', async () => {
await runScenarios(backendCases.flatMap(backend => ['host', 'backend', 'account', 'new-operation', 'busy', 'offline'].flatMap(change => ['success', 'error'].map(outcome => ({
name: `${backend}/${change}/${outcome}`, run: async () => {
const fixture = workspaceFixture()
const response = deferred<any>()
const request = createRequest(fixture, backend).mockReturnValueOnce(response.promise)
const pending = fixture.get().workspaceCreate('/old', backend)
expect(request).toHaveBeenCalledOnce()
if (change === 'host') fixture.switchHost()
if (change === 'backend') fixture.replaceBackend()
if (change === 'account') fixture.set({ config: { baseUrl: 'https://other.invalid' } })
if (change === 'offline') fixture.set({ connection: { phase: 'offline', stats: { mode: 'Disconnected', connected: false } } })
let successor: Promise<unknown> | undefined
const next = deferred<any>()
if (change === 'new-operation') {
request.mockReturnValueOnce(next.promise)
successor = fixture.get().workspaceCreate('/new', backend)
} else if (change === 'busy') fixture.set({ busyAction: 'new operation' })
fixture.set({ workspaces: [workspace('new')], error: 'new error' })
const expected = fixture.get()
if (outcome === 'success') response.resolve(createResponse(backend, 'old'))
else response.reject(new Error('old failure'))
expect(await pending).toBeUndefined()
expect(fixture.get()).toEqual(expected)
if (successor) {
next.resolve(createResponse(backend, 'new'))
expect(await successor).toBeDefined()
expect(fixture.get().busyAction).toBeUndefined()
}
},
})))), prepare)
})
it('retains normal creation and current error handling for all backends', async () => {
await runScenarios(backendCases.flatMap(backend => ['success', 'error'].map(outcome => ({ name: `${backend}/${outcome}`, run: async () => {
const fixture = workspaceFixture()
const request = createRequest(fixture, backend)
if (outcome === 'success') request.mockResolvedValueOnce(createResponse(backend, 'created'))
else request.mockRejectedValueOnce(new Error('current failure'))
const result = await fixture.get().workspaceCreate('/created', backend)
expect(fixture.get().busyAction).toBeUndefined()
if (outcome === 'success') {
expect(result).toBeDefined()
expect(fixture.get().workspaces.some(item => item.workspaceId === 'created')).toBe(true)
} else {
expect(result).toBeUndefined()
expect(fixture.get().error).toBe('current failure')
}
} }))), prepare)
})
it('ignores retired rename/delete/move/directory and catalog completions, including errors', async () => {
await runScenarios(['rename', 'delete', 'move', 'directory', 'refresh'].flatMap(operation => ['success', 'error'].map(outcome => ({
name: `${operation}/${outcome}`, run: async () => {
const fixture = workspaceFixture()
const response = deferred<any>()
const request = operation === 'rename' ? fixture.proxy.workspaceRename : operation === 'delete' ? fixture.proxy.workspaceDelete
: operation === 'move' ? fixture.proxy.workspaceInsertBefore : operation === 'directory' ? fixture.proxy.hostListDirectory : fixture.proxy.workspaceList
request.mockReturnValueOnce(response.promise)
const pending = operation === 'rename' ? fixture.get().workspaceRename('existing', 'new title')
: operation === 'delete' ? fixture.get().workspaceDelete('existing') : operation === 'move' ? fixture.get().workspaceMove('existing')
: operation === 'directory' ? fixture.get().hostListDirectory('/') : fixture.get().refreshWorkspaces()
await vi.waitFor(() => expect(request).toHaveBeenCalledOnce())
fixture.switchHost()
fixture.set({ workspaces: [workspace('new')], error: 'new error' })
const expected = fixture.get()
if (outcome === 'error') response.reject(new Error('old error'))
else response.resolve(operation === 'rename' ? workspace('existing') : operation === 'move' ? ['existing']
: operation === 'refresh' ? { items: [workspace('old')], archivedSessionIds: ['old-session'] } : undefined)
await pending
expect(fixture.get()).toEqual(expected)
},
}))), prepare)
})
})