From 9a201ea2fcf1c496436057797bbc096b694ae07d Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:26:20 +0800 Subject: [PATCH] Import apps/android/tests/state-operation-isolation.test.ts --- .../tests/state-operation-isolation.test.ts | 393 ++++++++++++++++++ 1 file changed, 393 insertions(+) create mode 100644 apps/android/tests/state-operation-isolation.test.ts diff --git a/apps/android/tests/state-operation-isolation.test.ts b/apps/android/tests/state-operation-isolation.test.ts new file mode 100644 index 0000000..9a5013d --- /dev/null +++ b/apps/android/tests/state-operation-isolation.test.ts @@ -0,0 +1,393 @@ +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(), + createCodexWorkspace: mocks.createCodex, loadCodexCatalog: mocks.loadCodex, +})) +vi.mock('../src/services/antigravity', async importOriginal => ({ + ...await importOriginal(), loadAntigravityCatalog: mocks.loadAgy, +})) +vi.mock('../src/services/claude', async importOriginal => ({ + ...await importOriginal(), loadClaudeCatalog: mocks.loadClaude, +})) +vi.mock('../src/services/pi', async importOriginal => ({ + ...await importOriginal(), loadPiCatalog: mocks.loadPi, +})) +vi.mock('../src/services/hermes', async importOriginal => ({ + ...await importOriginal(), loadHermesCatalog: mocks.loadHermes, +})) +vi.mock('../src/services/opencode', async importOriginal => ({ + ...await importOriginal(), 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() { + let resolve!: (value: T) => void + let reject!: (reason: unknown) => void + const promise = new Promise((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() + 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) + 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() + 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() + 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, 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() + 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() + 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 | undefined + const next = deferred() + 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() + 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) + }) +})