test: remove low-value policy and native test examples

This commit is contained in:
OrcaWin
2026-11-08 21:50:47 -08:00
parent 345ffb56d2
commit 4ebe3cf23f
42 changed files with 7 additions and 2468 deletions
@@ -54,12 +54,6 @@ const checks = [
],
enabled: process.platform === 'linux'
},
{
name: 'Linux set_value tests',
command: 'python3',
args: ['native/computer-use-linux/set_value_test.py'],
enabled: true
},
{
name: 'Windows provider PowerShell parse',
command: process.platform === 'win32' ? 'powershell.exe' : 'pwsh',
@@ -83,7 +77,7 @@ const checks = [
enabled: process.platform === 'win32'
},
{
name: 'Windows snapshot renderer tests',
name: 'Windows pointer safety tests',
command: 'powershell.exe',
args: [
'-NoLogo',
@@ -91,7 +85,7 @@ const checks = [
'-ExecutionPolicy',
'Bypass',
'-File',
'native/computer-use-windows/runtime-render.test.ps1'
'native/computer-use-windows/runtime-pointer.test.ps1'
],
enabled: process.platform === 'win32'
},
@@ -1,31 +0,0 @@
import { describe, expect, it } from 'vitest'
import { classifyMobileArtifact } from './mobile-artifact-kind'
describe('classifyMobileArtifact', () => {
it('classifies raster image extensions (case-insensitive)', () => {
for (const p of ['a.png', 'b.JPG', 'c/d.jpeg', 'e.gif', 'f.webp', 'g.bmp', 'h.ico']) {
expect(classifyMobileArtifact(p)).toBe('image')
}
})
it('keeps svg off the raster image path', () => {
expect(classifyMobileArtifact('logo.SVG')).toBe('vector')
})
it('classifies html extensions', () => {
expect(classifyMobileArtifact('index.html')).toBe('html')
expect(classifyMobileArtifact('a/b/page.HTM')).toBe('html')
})
it('treats code/text/unknown as other', () => {
for (const p of ['main.ts', 'README.md', 'data.csv', 'notes', 'a.pdf', 'x.json']) {
expect(classifyMobileArtifact(p)).toBe('other')
}
})
it('treats a dotfile or no-extension path as other', () => {
expect(classifyMobileArtifact('.gitignore')).toBe('other')
expect(classifyMobileArtifact('Makefile')).toBe('other')
expect(classifyMobileArtifact('dir/.env')).toBe('other')
})
})
+1 -32
View File
@@ -3,7 +3,7 @@ import type {
AccountProviderRateLimits,
AccountsSnapshot
} from '../../components/account-usage-state'
import { selectHomeUsageCards, selectHomeUsageSections } from './home-usage-cards'
import { selectHomeUsageCards } from './home-usage-cards'
function limits(
provider: 'claude' | 'codex',
@@ -75,23 +75,6 @@ describe('selectHomeUsageCards', () => {
])
})
it('shows System default first while no managed account is active, metered only once it has quota', () => {
const withoutQuota = selectHomeUsageCards(
snapshot({ codex: { accounts: [{ id: 'x', email: 'x@example.com', updatedAt: 1 }] } }),
'codex'
)
expect(withoutQuota.map((card) => [card.accountId, card.active, card.metered])).toEqual([
[null, true, false],
['x', false, true]
])
const withQuota = selectHomeUsageCards(
snapshot({ rateLimits: { codex: limits('codex', 40) } }),
'codex'
)
expect(withQuota.map((card) => [card.accountId, card.metered])).toEqual([[null, true]])
})
it('reads the Codex active account for the rate-limit runtime target', () => {
const cards = selectHomeUsageCards(
snapshot({
@@ -113,17 +96,3 @@ describe('selectHomeUsageCards', () => {
])
})
})
describe('selectHomeUsageSections', () => {
it('skips providers with nothing to show and drops an unfetched updatedAt', () => {
const sections = selectHomeUsageSections(
snapshot({
codex: { accounts: [{ id: 'x', email: 'x@example.com', updatedAt: 1 }] },
rateLimits: { codex: limits('codex', 5, { updatedAt: 0, status: 'idle' }) }
})
)
expect(sections.map((section) => [section.provider, section.updatedAt])).toEqual([
['codex', null]
])
})
})
@@ -2,15 +2,6 @@ import { describe, expect, it } from 'vitest'
import { MobileDictationPendingAudioBudget } from './mobile-dictation-pending-audio-budget'
describe('MobileDictationPendingAudioBudget', () => {
it('caps pending raw PCM audio at thirty seconds', () => {
const budget = new MobileDictationPendingAudioBudget()
expect(budget.tryReserve(959_999)).toBe(true)
expect(budget.tryReserve(1)).toBe(true)
expect(budget.pendingAudioBytes).toBe(960_000)
expect(budget.tryReserve(1)).toBe(false)
expect(budget.pendingAudioBytes).toBe(960_000)
})
it('releases completed chunks and clamps stale releases after reset', () => {
const budget = new MobileDictationPendingAudioBudget(10)
-31
View File
@@ -1,5 +1,3 @@
import { sayMobileAgentSessionFailure } from '../session/agent-session-failure-copy'
import { agentSessionFailureSentence } from '../../../src/shared/agent-session/failures/agent-session-failure-words'
import { beforeEach, describe, expect, it, vi } from 'vitest'
const pending = new Map<string, (catalog: Record<string, unknown>) => void>()
@@ -15,8 +13,6 @@ vi.mock('./locale-catalog-imports', () => ({
const { activateMobileUiLocale, getMobileUiLocale, mobileI18n, translate } =
await import('./mobile-i18n')
const settle = () => new Promise((resolve) => setTimeout(resolve, 0))
describe('activateMobileUiLocale', () => {
beforeEach(async () => {
pending.clear()
@@ -36,18 +32,6 @@ describe('activateMobileUiLocale', () => {
expect(translate('greeting', 'Hello')).toBe('こんにちは')
})
it('reads the existing saved uncertain fact through the current lazy failure translation table', async () => {
const sentence = () =>
agentSessionFailureSentence({ kind: 'unconfirmed' }, 'row', {}, sayMobileAgentSessionFailure)
expect(sentence()).toBe("Couldn't confirm whether this was sent. It hasn't been resent.")
const spanish = activateMobileUiLocale('es')
pending.get('es')?.({
session: { failure: { unconfirmed: 'El resultado sigue siendo desconocido.' } }
})
await spanish
expect(sentence()).toBe('El resultado sigue siendo desconocido.')
})
it('falls back to English when a catalog cannot load', async () => {
failing.add('de')
vi.spyOn(console, 'warn').mockImplementation(() => {})
@@ -55,19 +39,4 @@ describe('activateMobileUiLocale', () => {
expect(getMobileUiLocale()).toBe('en')
expect(translate('greeting', 'Hello')).toBe('Hello')
})
it('picks CLDR plural forms and English fallbacks for missing keys', async () => {
const russian = activateMobileUiLocale('ru')
await settle()
pending.get('ru')?.({
files_one: '{{count}} файл',
files_few: '{{count}} файла',
files_many: '{{count}} файлов'
})
await russian
expect(
[1, 3, 5, 21].map((count) => translate('files_one', '{{count}} file', { count }))
).toEqual(['1 файл', '3 файла', '5 файлов', '21 файл'])
expect(translate('untranslated', 'Still English')).toBe('Still English')
})
})
@@ -148,17 +148,6 @@ describe('what the audio schemas refuse', () => {
})
describe('the shell capture', () => {
it('surfaces a denied microphone as data rather than as a throw', async () => {
const { engine, calls } = createTestEngine({ permission: async () => 'denied' })
const capture = createCapture(engine)
await expect(capture.serve('native.audio.start', { sampleRate: 16_000 })).resolves.toEqual({
started: false,
sampleRate: 16_000,
permission: 'denied'
})
expect(calls).toEqual([])
})
it('serves a partial drain from the front and keeps the rest for the next read', async () => {
const { engine, emit } = createTestEngine()
const capture = createCapture(engine)
@@ -211,24 +200,6 @@ describe('the shell capture', () => {
expect(next.interruption).toBeNull()
})
it('keeps a capture the OS handed back, and ends the two it took away', async () => {
const { engine, interrupt } = createTestEngine()
const capture = createCapture(engine)
await capture.serve('native.audio.start', { sampleRate: 16_000 })
interrupt('ended')
const kept = audioReadResultSchema.parse(
await capture.serve('native.audio.read', { maxBytes: BRIDGE_AUDIO_RING_MAX_BYTES })
)
// Nonterminal interruption still reaches the page while the live capture keeps filling its ring.
expect(kept.interruption).toBe('ended')
expect(kept.recording).toBe(true)
interrupt('blocked')
const lost = audioReadResultSchema.parse(
await capture.serve('native.audio.read', { maxBytes: BRIDGE_AUDIO_RING_MAX_BYTES })
)
expect(lost.recording).toBe(false)
})
it('refuses a read once the page has stopped', async () => {
const { engine } = createTestEngine()
const capture = createCapture(engine)
@@ -264,24 +235,6 @@ describe('the shell capture', () => {
expect(read.base64).toBe('')
})
it('replaces a capture a page left behind rather than refusing the new one', async () => {
// A page can reload or vanish mid-capture; only the shell sees that lifecycle, so a new start replaces the old capture.
const { engine, emit, log } = createTestEngine()
const capture = createCapture(engine)
await capture.serve('native.audio.start', { sampleRate: 16_000 })
emit(pcm(2_048, 6))
await expect(capture.serve('native.audio.start', { sampleRate: 16_000 })).resolves.toEqual({
started: true,
sampleRate: 16_000,
permission: 'granted'
})
expect(log.filter((entry) => entry === 'end')).toHaveLength(1)
const read = audioReadResultSchema.parse(
await capture.serve('native.audio.read', { maxBytes: BRIDGE_AUDIO_RING_MAX_BYTES })
)
expect(read.base64).toBe('')
})
it('leaves one capture behind when two starts race the permission prompt', async () => {
// Concurrent starts can both leave the OS prompt and reach listen; replacement must remove the earlier handlers rather than leak a ring nobody drains.
const entered = gate()
@@ -371,37 +324,9 @@ describe('the shell capture', () => {
await expect(stopped).resolves.toEqual({ stopped: true, base64: '', droppedBytes: 0 })
expect(liveListeners()).toEqual({ microphone: 0, interruptions: 0 })
})
it('ends the capture when the page session does', async () => {
const { engine, log } = createTestEngine()
const capture = createCapture(engine)
await capture.serve('native.audio.start', { sampleRate: 16_000 })
capture.dispose()
expect(log).toContain('end')
await expect(capture.serve('native.audio.read', { maxBytes: 16 })).rejects.toBeInstanceOf(
BridgeNativeVerbRefusedError
)
})
})
describe('the screen the shell holds awake while it is capturing', () => {
it('takes the screen on a start and gives it back on a stop', async () => {
const { engine, screen } = createTestEngine()
const capture = createCapture(engine)
await capture.serve('native.audio.start', { sampleRate: 16_000 })
expect(screen).toEqual(['+'])
await capture.serve('native.audio.stop', {})
expect(screen).toEqual(['+', '-'])
})
it('gives it back when the page session ends with a capture still open', async () => {
const { engine, screen } = createTestEngine()
const capture = createCapture(engine)
await capture.serve('native.audio.start', { sampleRate: 16_000 })
capture.dispose()
expect(screen).toEqual(['+', '-'])
})
it('gives it back when the engine throws after the capture is open', async () => {
const { engine, screen } = createTestEngine({
begin: () => {
@@ -443,14 +368,4 @@ describe('the tail the stop reply carries', () => {
expect(Array.from(decode(read.base64))).toEqual(Array.from(spoken))
expect(Array.from(decode(stopped.base64))).toEqual(Array.from(after))
})
it('leaves nothing behind for a second stop to answer with', async () => {
const { engine, emit } = createTestEngine()
const capture = createCapture(engine)
await capture.serve('native.audio.start', { sampleRate: 16_000 })
emit(pcm(512, 5))
await capture.serve('native.audio.stop', {})
const again = audioStopResultSchema.parse(await capture.serve('native.audio.stop', {}))
expect(again).toEqual({ stopped: false, base64: '', droppedBytes: 0 })
})
})
@@ -77,31 +77,6 @@ describe('bridge client refusals and send failures', () => {
expect(isRpcDeliveryUnknown(error)).toBe(true)
})
it('leaves a refused frame that names no open exchange to the diagnostic alone', async () => {
const page = createPageClient()
page.start()
const answer = page.client.sendRequest('worktree.ps')
page.deliver({
v: BRIDGE_PROTOCOL_VERSION,
type: 'reply',
id: 'ZZZZZZZZZZZZZZZZZZZZZZ',
payload: { id: 'frame-1', ok: true }
})
expect(page.diagnostics).toEqual([{ kind: 'refused', refusal: 'unrecognised-message' }])
page.deliver({
v: BRIDGE_PROTOCOL_VERSION,
type: 'reply',
id: idOf(page, 0),
payload: { id: 'frame-1', ok: true, result: 7, _meta: { runtimeId: 'runtime-a' } }
})
await expect(answer).resolves.toEqual({
id: 'frame-1',
ok: true,
result: 7,
_meta: { runtimeId: 'runtime-a' }
})
})
it('fails a request whose frame never left the page, without the delivery mark', async () => {
let live = true
const page = createPageClient({
@@ -6,9 +6,7 @@ import './bridge-port-pair-test-harness'
import './bridge-client-subscriptions'
import { BRIDGE_PROTOCOL_VERSION, type BridgeHostMessage } from './bridge-envelope'
import './bridge-client-init-handshake'
import { BridgeClientNotReadyError } from './bridge-rpc-client'
import {
CONNECTION,
INIT,
createPageClient,
eventFrame,
@@ -60,19 +58,6 @@ describe('bridge client handshake', () => {
})
})
describe('bridge client before a session', () => {
it('drops a state frame that beat init rather than priming from it', () => {
const page = createPageClient()
page.deliver({
v: BRIDGE_PROTOCOL_VERSION,
type: 'state',
connection: { ...CONNECTION, state: 'reconnecting' }
})
expect(() => page.client.getState()).toThrow(BridgeClientNotReadyError)
expect(page.diagnostics).toEqual([])
})
})
// Catch page-listener throws locally: iOS callAsyncJavaScript would otherwise reject an already-delivered frame. Retrying cannot fix the same listener failure (ruling 34 addendum).
describe('bridge client after close', () => {
@@ -1,82 +0,0 @@
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
// Avoid Expo imports through re-exported screen hooks; this test calls none of them.
vi.mock('../../transport/connection/host-client-hooks', () => ({
useDisconnectHostClient: () => () => {},
useForceReconnect: () => null,
useForgetHostClient: () => () => {},
useHostClient: () => ({ client: null, clientId: null, state: 'disconnected' }),
usePrimeHosts: () => () => {},
useRefreshHostClient: () => () => {}
}))
import { RpcClientProvider } from '../../transport/connection/client-context.web'
import { BRIDGE_PROTOCOL_VERSION } from './bridge-envelope'
import { BRIDGE_NATIVE_VERB_NAMES } from './bridge-native-verbs'
import './bridge-port-pair-test-harness'
import { GRANTS, INIT, createPageClient } from './bridge-page-client-test-harness'
import { NativeVerbError, useNativeVerbs, type NativeVerbs } from './use-native-verbs'
const mounted: ReactTestRenderer[] = []
const held: { verbs: NativeVerbs | null } = { verbs: null }
function Screen(): null {
held.verbs = useNativeVerbs()
return null
}
beforeEach(() => {
held.verbs = null
})
afterEach(() => {
act(() => {
for (const tree of mounted.splice(0)) {
tree.unmount()
}
})
vi.useRealTimers()
})
// The typed member must reject desktop methods too; widened callers could otherwise bypass the raw-port inventory’s call shapes.
describe('a code this page has never heard of', () => {
it('floors to unreported rather than crossing verbatim', async () => {
// Inject a newer-shell code directly; this host normalizes unknown codes before sending, so the pair cannot produce it itself.
const page = createPageClient()
page.deliver({ ...INIT, grants: { ...GRANTS, native: [...BRIDGE_NATIVE_VERB_NAMES] } })
act(() => {
create(
<RpcClientProvider client={page.client}>
<Screen />
</RpcClientProvider>
)
})
const verbs = held.verbs
if (verbs === null) {
throw new Error('nothing mounted')
}
const read = verbs.readClipboardText().catch((error: unknown) => error)
const sent = page.frames().filter((frame) => frame.type === 'request')
const id = sent.at(-1)?.type === 'request' ? sent.at(-1)?.id : undefined
if (id === undefined) {
throw new Error('no request went out')
}
page.deliver({
v: BRIDGE_PROTOCOL_VERSION,
type: 'error',
id,
error: {
category: 'BridgeNativeVerbRefusedError',
code: 'native_verb_something_new',
message: 'a verb from a later build',
isRpcDeliveryUnknown: false
}
})
const caught = await read
expect(caught).toBeInstanceOf(NativeVerbError)
expect(caught instanceof NativeVerbError && caught.reason).toBe('unreported')
})
})
@@ -5,8 +5,7 @@ import type { MobileWebBundleFetchResult } from '../transport/web-bundle/mobile-
import { computeMobileWebBundleId } from '../../../src/shared/mobile-web-bundle/manifest-contract'
import {
createFakeGenerationFileSystem as createFakeFileSystem,
FAKE_GENERATION_ROOT,
type FakeGenerationFileSystem as FakeFileSystem
FAKE_GENERATION_ROOT
} from './generation-file-system-fake'
const ROOT = FAKE_GENERATION_ROOT
@@ -106,17 +105,6 @@ describe('generation store', () => {
expect(fs.paths().some((path) => path.includes('/tmp'))).toBe(false)
})
it('replaces the previous generation when the build id changes', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
await activate(store, HOST, buildResult(SECOND))
expect(fs.paths().some((path) => path.includes(BUILD))).toBe(false)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(SECOND_BUILD)
})
it('reads two generations as no activation and drops the host tree', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
@@ -183,18 +171,6 @@ describe('generation store', () => {
expect((await store.readActiveGeneration(oldest))?.buildId).toBe(BUILD)
})
it('returns the generation when an open cannot write the index', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const other = deriveHostCacheKey('other')
await activate(store, HOST)
await activate(store, other)
fs.failWritesAt('hosts.json')
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBe(JSON.stringify([HOST, other]))
})
it('never counts or evicts a host that is only mid-download', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
@@ -246,17 +222,6 @@ describe('generation store', () => {
])
})
it('drops residue from an earlier attempt instead of staging over it', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const staging = `${HOST}/tmp/${BUILD}`
fs.seed(`${staging}/assets/orphan.js`, { kind: 'file', bytes: new Uint8Array(1) })
await store.stageGeneration(HOST, buildResult({}))
expect(fs.paths().some((path) => path.endsWith('orphan.js'))).toBe(false)
})
it('refuses a path that escapes the staged tree, and a host key that is not one', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
@@ -279,20 +244,6 @@ describe('generation store', () => {
expect(fs.paths()).toEqual([])
})
it('deletes one host tree without touching another', async () => {
const fs = createFakeFileSystem()
const other = deriveHostCacheKey('host-b')
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
await activate(store, other)
await store.deleteHostCache(HOST)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect((await store.readActiveGeneration(other))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBe(JSON.stringify([other]))
})
it('refuses a rename that did not carry the tree, as Android below API 26 can', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
@@ -322,17 +273,6 @@ describe('generation store', () => {
expect(fs.paths().some((path) => path.startsWith(HOST))).toBe(false)
})
it('activates normally when the recency index cannot be read', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.seed('hosts.json', { kind: 'file', bytes: new TextEncoder().encode('[]') })
fs.failReadsAt('hosts.json')
await activate(store, HOST)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
})
it('replaces an entry named for the build id that is not a readable generation', async () => {
const build = BUILD
// Model a crash between rename and the post-rename manifest check.
@@ -351,31 +291,6 @@ describe('generation store', () => {
}
})
it('drops an aborted staging without touching the activation', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const staged = await store.stageGeneration(HOST, buildResult(SECOND))
await store.abortStagedGeneration(staged)
expect(fs.paths().some((path) => path.includes(SECOND_BUILD))).toBe(false)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
})
it('returns the activation even when the recency index cannot be written', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.failWritesAt('hosts.json')
const staged = await store.stageGeneration(HOST, buildResult({}))
const active = await store.commitGeneration(staged)
expect(active.buildId).toBe(BUILD)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBeNull()
})
it('refuses a handle whose staged tree is gone without touching the activation', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
@@ -470,41 +385,6 @@ describe('reusable assets for the next download', () => {
})
})
// Older builds could leave manifest-next.json after an interrupted rewrite; this reader must ignore it.
describe('a pending manifest left by an older build', () => {
const MANIFEST_PATH = `${HOST}/generations/${BUILD}/manifest.json`
const NEXT_PATH = `${HOST}/generations/${BUILD}/manifest-next.json`
function seedPending(fs: FakeFileSystem): void {
const body = JSON.stringify({ ...buildResult({}).manifest, routes: [] })
fs.seed(NEXT_PATH, { kind: 'file', bytes: new TextEncoder().encode(body) })
}
it('reads the manifest beside it and leaves it inert', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const stored = fs.text(MANIFEST_PATH)
seedPending(fs)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
expect(fs.text(MANIFEST_PATH)).toBe(stored)
})
it('drops the host tree for a redownload when it is the only manifest left', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
seedPending(fs)
await fs.delete(`${ROOT}/${MANIFEST_PATH}`)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths().some((path) => path.startsWith(`${HOST}/generations`))).toBe(false)
})
})
// Commit deletes the old build first, so it must not run under a page still loading that build's chunks.
describe('an update staged behind a live page', () => {
it('stays staged while a page reads the old build, and the next read after it commits', async () => {
@@ -101,19 +101,9 @@ describe('folding while the host-area page shows a session', () => {
expect(dependencies.push.mock.calls).toEqual([[DETAIL]])
})
it('stays on the list when the page was showing the list', async () => {
await foldAfterPageShows(HOST)
expect(dependencies.push).not.toHaveBeenCalled()
})
it('leaves the stack alone from a host-route shell covered by a pushed session', async () => {
await foldAfterPageShows(HOST, false)
expect(dependencies.push).not.toHaveBeenCalled()
expect(dependencies.dispatch).not.toHaveBeenCalled()
})
it('stays on the list for an older page that never reports where it is', async () => {
await foldAfterPageShows(null)
expect(dependencies.push).not.toHaveBeenCalled()
})
})
@@ -1,216 +0,0 @@
import { createElement } from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { beforeEach, describe, expect, it, vi } from 'vitest'
import type { MobileWebBundleManifestRead } from '../transport/web-bundle/mobile-web-bundle-reply-schemas'
import type {
MobileWebShellSessionState,
MobileWebShellUpdateNotice
} from './mobile-web-shell-session-contract'
// Exercise the real hook/store over in-memory disk; stub network and native modules.
type Doubles = {
connection: { client: object | null; state: string }
gates: {
statusPending: boolean
statusReadable: boolean
hostCapabilities: string[]
hostProtocolWindow: { protocolVersion: number; minCompatibleMobileVersion: number }
}
manifest: MobileWebBundleManifestRead | null
fetch: () => Promise<MobileWebBundleFetchResult>
}
const doubles = vi.hoisted((): Doubles => ({
connection: { client: {}, state: 'connected' },
gates: {
statusPending: false,
statusReadable: true,
hostCapabilities: [],
hostProtocolWindow: { protocolVersion: 10, minCompatibleMobileVersion: 1 }
},
manifest: null,
fetch: () => Promise.reject(new Error('no fetch staged'))
}))
vi.mock('expo-crypto', () => ({ getRandomBytes: (length: number) => new Uint8Array(length) }))
vi.mock('expo-file-system', () => ({ Directory: class {}, File: class {}, Paths: { cache: '' } }))
vi.mock('react-native', () => ({ AppState: {} }))
vi.mock('../transport/encryption/mobile-session-id-encoding', () => ({
encodeBase64Url: () => 'session-id'
}))
vi.mock('../components/host-protocol-gates-context', () => ({
useHostProtocolGates: () => doubles.gates
}))
vi.mock('../transport/connection/host-client-hooks', () => ({
useHostClient: () => doubles.connection
}))
vi.mock('../transport/rpc/rpc-operation', () => ({
defineRpcOperation: (definition: unknown) => definition,
runRpcOperation: async () => {
if (doubles.manifest === null) {
throw new Error('the test reached the host with no manifest staged')
}
return { manifest: doubles.manifest }
}
}))
vi.mock('../transport/web-bundle/mobile-web-bundle-fetch', () => ({
fetchMobileWebBundle: () => doubles.fetch()
}))
import {
computeMobileWebBundleId,
MOBILE_WEB_BUNDLE_SCHEMA_VERSION,
type MobileWebBundleAsset
} from '../../../src/shared/mobile-web-bundle/manifest-contract'
import { MOBILE_WEB_BUNDLE_CAPABILITY } from '../../../src/shared/mobile-web-bundle/mobile-web-bundle-capability'
import type { MobileWebBundleFetchResult } from '../transport/web-bundle/mobile-web-bundle-fetch'
import { MobileWebBundleFetchError } from '../transport/web-bundle/mobile-web-bundle-fetch-refusal'
import { MobileWebBundleManifestReadSchema } from '../transport/web-bundle/mobile-web-bundle-reply-schemas'
import {
createFakeGenerationFileSystem,
FAKE_GENERATION_ROOT,
type FakeGenerationFileSystem
} from './generation-file-system-fake'
import { createGenerationStore } from './generation-store'
import { deriveHostCacheKey } from './host-cache-key'
import { useMobileWebShellSession } from './use-mobile-web-shell-session'
const HOST_ID = 'host-1'
const HOST_KEY = deriveHostCacheKey(HOST_ID)
const ROUTE_PATHNAME = '/h/host-1'
const ROUTE_PATTERN = '/h/[hostId]'
function assetsFilled(fill: number) {
return [
{ path: 'index.html', sha256: `${fill}`.repeat(64), byteLength: 4, contentType: 'text/html' },
{
path: 'assets/app.js',
sha256: `${fill + 1}`.repeat(64),
byteLength: 2,
contentType: 'text/javascript'
}
]
}
const GOOD_ASSETS = assetsFilled(1)
const NEWER_ASSETS = assetsFilled(5)
const TOTAL_BYTES = 6
// Derive ids from assets so cached fixtures pass the manifest digest check.
function manifestOf(
assets: readonly MobileWebBundleAsset[],
runtimeProtocolVersion = 5
): MobileWebBundleManifestRead {
return MobileWebBundleManifestReadSchema.parse({
schemaVersion: MOBILE_WEB_BUNDLE_SCHEMA_VERSION,
buildId: computeMobileWebBundleId(assets),
minCompatibleRuntimeProtocolVersion: 2,
runtimeProtocolVersion,
pageVersion: 1,
entrypoint: 'index.html',
totalBytes: TOTAL_BYTES,
assets,
routes: [{ pathname: ROUTE_PATTERN, grants: ['navigate'] }]
})
}
const GOOD_MANIFEST = manifestOf(GOOD_ASSETS)
const NEWER_MANIFEST = manifestOf(NEWER_ASSETS)
function fetchResultFor(manifest: MobileWebBundleManifestRead): MobileWebBundleFetchResult {
return {
manifest,
assets: new Map(
manifest.assets.map((asset) => [asset.path, new Uint8Array(asset.byteLength).fill(7)])
),
reused: [],
totalBytes: TOTAL_BYTES,
elapsedMs: 1
}
}
// Stage/commit N through the real store so fallback reads the tree a successful download actually leaves.
async function cacheGeneration(
fileSystem: FakeGenerationFileSystem,
manifest: MobileWebBundleManifestRead = GOOD_MANIFEST
): Promise<void> {
const store = createGenerationStore({ fileSystem })
await store.commitGeneration(await store.stageGeneration(HOST_KEY, fetchResultFor(manifest)))
}
function refuseTheAssets(): Promise<MobileWebBundleFetchResult> {
return Promise.reject(
new MobileWebBundleFetchError(
'asset-short',
'bundle asset assets/app.js ended at 1 of 2 declared bytes'
)
)
}
type Mounted = {
unmount: () => Promise<void>
state: () => MobileWebShellSessionState
updateNotice: () => MobileWebShellUpdateNotice | null
}
async function mountRoute(fileSystem: FakeGenerationFileSystem): Promise<Mounted> {
const latest: {
state: MobileWebShellSessionState
updateNotice: MobileWebShellUpdateNotice | null
} = { state: { kind: 'checking' }, updateNotice: null }
function Probe() {
const session = useMobileWebShellSession({
hostId: HOST_ID,
routePathname: ROUTE_PATHNAME,
runtime: {
createStore: () => createGenerationStore({ fileSystem }),
mintSessionId: () => 'session-id',
claimSpareSessionId: async () => null,
now: () => 0,
setForegroundTimer: () => () => {}
}
})
latest.state = session.state
latest.updateNotice = session.updateNotice
return null
}
const rendered: { tree: ReactTestRenderer | null } = { tree: null }
await act(async () => {
rendered.tree = create(createElement(Probe))
})
const tree = rendered.tree
if (tree === null) {
throw new Error('the hook did not mount')
}
return {
unmount: async () => {
await act(async () => {
tree.unmount()
})
},
state: () => latest.state,
updateNotice: () => latest.updateNotice
}
}
describe('an update the shell refuses while the host is reachable', () => {
beforeEach(() => {
doubles.connection = { client: {}, state: 'connected' }
doubles.gates.hostCapabilities = [MOBILE_WEB_BUNDLE_CAPABILITY]
doubles.manifest = NEWER_MANIFEST
doubles.fetch = refuseTheAssets
})
it('records a failure whose error named an endpoint and a token without either', async () => {
doubles.fetch = () =>
Promise.reject(new Error('dial wss://relay.example/pair?token=SECRET-123 refused'))
const fileSystem = createFakeGenerationFileSystem()
await cacheGeneration(fileSystem)
await mountRoute(fileSystem)
const log = await fileSystem.readText(`${FAKE_GENERATION_ROOT}/update-failures.json`)
expect(log).toContain('unrecognised-error')
expect(log).not.toMatch(/SECRET|token|\?|:\/\/|relay/)
})
})
@@ -177,17 +177,6 @@ describe('only the state that mounted the view hears the view', () => {
// A finished WebView load can still have failed script evaluation; only page ready proves its code ran.
describe('the page has to speak for the document that loaded', () => {
it('does nothing when the wait expires after the page has spoken', () => {
const step = run(
readySession().session,
{ type: 'document-loaded' },
{ type: 'page-ready' },
{ type: 'page-ready-deadline' }
)
expect(step.effects).toEqual([])
expect(step.session.state.kind).toBe('ready')
})
it('leaves a remounted document its own wait when the first one expires late', () => {
const first = run(readySession().session, { type: 'document-loaded' }, { type: 'page-ready' })
const armed = first.session.flow
@@ -245,15 +234,6 @@ describe('a cached page opened before the verdict', () => {
)
}
it('checks for a newer build once the verdict opens, and stages it behind the page', () => {
const opened = run(openedWhileDialling().session, { type: 'gates-changed', gates: gates() })
expect(opened.session.state).toMatchObject({ kind: 'ready', sessionId: 'session-early' })
expect(opened.effects).toEqual([{ kind: 'read-manifest' }])
const staged = run(opened.session, { type: 'manifest-read', manifest: NEWER })
expect(staged.session.state).toMatchObject({ kind: 'ready', sessionId: 'session-early' })
expect(staged.effects).toEqual([{ kind: 'stage-update' }])
})
it('stages the newer build when the manifest answers after the page document starts', () => {
const opened = run(openedWhileDialling().session, { type: 'gates-changed', gates: gates() })
const asked = opened.session.flow
@@ -2,10 +2,7 @@ import type { ReactElement } from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { BRIDGE_MAX_ROUTE_HREF_CHARS } from '../mobile-web-shell/bridge/bridge-caps'
import {
BRIDGE_NAVIGATE_BACK_NOTIFY,
BRIDGE_PROTOCOL_VERSION
} from '../mobile-web-shell/bridge/bridge-envelope'
import { BRIDGE_PROTOCOL_VERSION } from '../mobile-web-shell/bridge/bridge-envelope'
import { createShellPageClient } from '../mobile-web-shell/bridge/page-bootstrap'
import type { BridgeRpcClient } from '../mobile-web-shell/bridge/bridge-rpc-client'
import type { RouteHandoff } from './route-handoff'
@@ -125,12 +122,6 @@ function navigations(posted: readonly string[]): unknown[] {
.filter((frame: { name?: string }) => frame.name === 'navigate')
}
function backs(posted: readonly string[]): unknown[] {
return posted
.map((json) => JSON.parse(json))
.filter((frame: { name?: string }) => frame.name === BRIDGE_NAVIGATE_BACK_NOTIFY)
}
const warned: unknown[][] = []
let restoreWarn: (() => void) | null = null
@@ -211,20 +202,6 @@ describe('a target the shell would refuse', () => {
})
})
// The initial document has one history entry; Back must ask the native stack unless the page has pushed its own screens.
describe('a back this document cannot serve', () => {
it('falls through to this document when the shell granted no navigate', () => {
const { posted, handoff } = mount({
...INIT,
grants: { ...INIT.grants, native: [] },
pageRoutes: []
})
handoff.back()
expect(backs(posted)).toEqual([])
expect(router.back).toHaveBeenCalled()
})
})
// Wrap every href-taking router member; spreading navigate/prefetch untouched would bypass page-route policy.
// Never hand prefetch to native navigate: a background optimization must not open a screen.
@@ -237,57 +214,3 @@ describe('prefetch', () => {
expect(router.push).not.toHaveBeenCalled()
})
})
// Local targets run under the opener’s grants; hand off any target needing more so its own session receives the required capabilities.
describe('an in-page hop the session cannot cover', () => {
const TASKS = '/h/host-a/tasks'
const PAIRS = [
{ pathname: '/h/[hostId]', grants: ['navigate', 'storage', 'haptics'] },
{
pathname: '/h/[hostId]/tasks',
grants: ['navigate', 'storage', 'externalLink', 'haptics', 'native.clipboard.write']
}
]
const withPairs = (native: string[]) => ({
...INIT,
grants: { ...INIT.grants, native },
pageRoutes: ['/h/[hostId]', '/h/[hostId]/tasks'],
pageRouteGrants: PAIRS
})
it('stays in this document when the session already covers the target', () => {
const { posted, handoff } = mount(
withPairs(['navigate', 'storage', 'externalLink', 'haptics', 'native.clipboard.write'])
)
handoff.push(TASKS)
expect(navigations(posted)).toEqual([])
expect(router.push).toHaveBeenCalledWith(TASKS, undefined)
})
it('keeps a hop whose target declares a subset, which is C3.1 without its pairwise pin', () => {
const { posted, handoff } = mount({
...INIT,
grants: { ...INIT.grants, native: ['navigate', 'storage', 'externalLink', 'haptics'] },
pageRoutes: ['/h/[hostId]/files/[worktreeId]', '/h/[hostId]/files/preview/[worktreeId]'],
pageRouteGrants: [
{ pathname: '/h/[hostId]/files/[worktreeId]', grants: ['navigate', 'storage', 'haptics'] },
{ pathname: '/h/[hostId]/files/preview/[worktreeId]', grants: ['navigate', 'haptics'] }
]
})
handoff.push('/h/host-a/files/preview/wt-1')
expect(navigations(posted)).toEqual([])
expect(router.push).toHaveBeenCalledWith('/h/host-a/files/preview/wt-1', undefined)
})
it('keeps the old rule when the shell named no grants, so an older shell is unchanged', () => {
// Absent pairs preserve older-shell behavior; absence does not declare an empty grant list.
const { posted, handoff } = mount({
...INIT,
grants: { ...INIT.grants, native: ['navigate', 'storage', 'haptics'] },
pageRoutes: ['/h/[hostId]', '/h/[hostId]/tasks']
})
handoff.push(TASKS)
expect(navigations(posted)).toEqual([])
expect(router.push).toHaveBeenCalledWith(TASKS, undefined)
})
})
@@ -1,9 +1,5 @@
import { beforeEach, expect, it, vi } from 'vitest'
import { AppState } from 'react-native'
import {
DEFAULT_NOTIFICATION_DELIVERY,
loadNotificationDeliveryPreferences
} from './notification-delivery-preferences'
import {
notificationViewingOfRoute,
sessionOfPageLocation,
@@ -52,8 +48,3 @@ it('suppresses the session a host list document shows inside itself, until its p
setHostDocumentSession('host-1', sessionOfPageLocation('/h/host-1'))
expect(shouldSuppressNotificationWhileViewing(event, 'host-1', true)).toBe(false)
})
it('recovers defaults from malformed stored preferences', async () => {
storage.set('orca:notificationDeliveryPreferences', '{broken')
expect(await loadNotificationDeliveryPreferences()).toEqual(DEFAULT_NOTIFICATION_DELIVERY)
})
@@ -89,13 +89,6 @@ describe('shouldSuppressForegroundPush', () => {
).resolves.toBe(false)
})
it('suppresses pushes for an unpaired host', async () => {
vi.mocked(loadHostCatalog).mockResolvedValue([])
await expect(
shouldSuppressForegroundPush(apnsData({ hostFingerprint, notificationSeq: 1 }))
).resolves.toBe(true)
})
it('suppresses a push after a matching persisted dismissal', async () => {
const { rememberPushDismissal } = await import('./push-dismissal-watermarks')
const payload = {
@@ -100,29 +100,6 @@ describe('mobile relay pairing journal store', () => {
})
})
it('records a provisional winner only for the active journal identity', async () => {
const journal = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
hostId: 'host-1',
hostName: 'Blue Whale',
randomBytes: (length) => new Uint8Array(length).fill(7)
})
await saveMobileRelayPairingJournal(journal)
await updateMobileRelayPairingJournal(journal.metadata.journalId, (metadata) => ({
...metadata,
winner: 'direct',
authorizationMode: 'authenticated-direct'
}))
await expect(
updateMobileRelayPairingJournal('stale-journal', (metadata) => metadata)
).rejects.toThrow(/stale/)
expect(JSON.parse(metadataRaw!)).toMatchObject({
winner: 'direct',
authorizationMode: 'authenticated-direct'
})
})
it('treats metadata without its secret record as an incomplete crash', async () => {
const journal = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
@@ -150,32 +127,6 @@ describe('mobile relay pairing journal store', () => {
expect(secretRaw).toBeNull()
})
it('replaces a journal that never selected an authorization path', async () => {
const journal = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
hostId: 'host-1',
hostName: 'Blue Whale',
randomBytes: (length) => new Uint8Array(length).fill(10)
})
await saveMobileRelayPairingJournal(journal)
const replacement = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
hostId: 'host-2',
hostName: 'Red Panda',
randomBytes: (length) => new Uint8Array(length).fill(12)
})
const replacementSave = saveMobileRelayPairingJournal(replacement)
const staleUpdate = updateMobileRelayPairingJournal(
journal.metadata.journalId,
(metadata) => metadata
)
await expect(replacementSave).resolves.toBeUndefined()
await expect(staleUpdate).rejects.toThrow(/stale/)
await expect(loadMobileRelayPairingJournal()).resolves.toEqual(replacement)
})
it('serializes a replacement behind an in-flight journal snapshot', async () => {
const journal = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
@@ -270,37 +221,6 @@ describe('mobile relay pairing journal store', () => {
await expect(replacementSave).rejects.toThrow(/pairing in progress/)
})
it.each([
['winner', { winner: 'direct' as const }],
['authorization mode', { authorizationMode: 'authenticated-direct' as const }]
])(
'refuses replacement while the attempt with a durable %s runs',
async (_name, authorization) => {
const created = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
hostId: 'host-1',
hostName: 'Blue Whale',
randomBytes: (length) => new Uint8Array(length).fill(10)
})
const journal = {
...created,
metadata: { ...created.metadata, ...authorization }
}
await saveMobileRelayPairingJournal(journal)
const replacement = createMobileRelayPairingJournal({
offer: offer as PairingOffer & { relay: NonNullable<PairingOffer['relay']> },
hostId: 'host-2',
hostName: 'Red Panda',
randomBytes: (length) => new Uint8Array(length).fill(12)
})
await expect(saveMobileRelayPairingJournal(replacement)).rejects.toThrow(
/pairing in progress/
)
await expect(loadMobileRelayPairingJournal()).resolves.toEqual(journal)
}
)
// New scans must supersede stranded authorized journals instead of blocking until expiry (#12518).
it('makes a superseding scan wait for a publication in progress, and refuses a stale claim', async () => {
@@ -1,43 +0,0 @@
import { Buffer } from 'node:buffer'
import { describe, expect, it } from 'vitest'
import { resolvePairConfirmRouteState } from './pair-confirm-state'
import type { PairingOffer } from '../../../src/shared/remote-runtime/pairing/mobile-relay-pairing-offer'
function encodeOffer(offer: PairingOffer): string {
return Buffer.from(JSON.stringify(offer))
.toString('base64')
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=+$/g, '')
}
describe('resolvePairConfirmRouteState', () => {
const offer: PairingOffer = {
v: 2,
endpoint: 'ws://192.168.1.10:6768',
deviceToken: 'token-abc',
publicKeyB64: 'pubkey-xyz'
}
it('accepts a valid pairing code', () => {
expect(resolvePairConfirmRouteState(encodeOffer(offer))).toEqual({
kind: 'ready',
offer,
errorMessage: ''
})
})
it('accepts a full pairing URL', () => {
expect(resolvePairConfirmRouteState(`orca://pair#${encodeOffer(offer)}`)).toEqual({
kind: 'ready',
offer,
errorMessage: ''
})
expect(resolvePairConfirmRouteState(`orca://pair?code=${encodeOffer(offer)}`)).toEqual({
kind: 'ready',
offer,
errorMessage: ''
})
})
})
@@ -1,87 +0,0 @@
// @vitest-environment happy-dom
// RN Web ignores keyboardShouldPersistTaps; focusable Pressables take mousedown focus and close the IME.
// @vitest-environment happy-dom
// RN Web ignores keyboardShouldPersistTaps; focusable Pressables take mousedown focus and close the IME.
import { afterEach, describe, expect, it, vi } from 'vitest'
import { keepTextFocusThroughTaps } from './keyboard-persisting-taps'
import type * as ReactNative from 'react-native'
vi.mock('react-native', () => vi.importActual<typeof ReactNative>('react-native-web'))
function plant() {
const container = document.createElement('div')
const button = document.createElement('div')
button.tabIndex = 0
const label = document.createElement('span')
button.appendChild(label)
const gap = document.createElement('span')
const field = document.createElement('input')
container.append(button, gap, field)
const liveInput = document.createElement('input')
document.body.append(container, liveInput)
return { container, label, gap, field, liveInput }
}
function pressKeepsFocus(target: Element): boolean {
const event = new MouseEvent('mousedown', { bubbles: true, cancelable: true })
target.dispatchEvent(event)
return event.defaultPrevented
}
afterEach(() => {
document.body.innerHTML = ''
})
describe('keepTextFocusThroughTaps', () => {
it("keeps a text field's focus through a tap on a pressable, in both modes", () => {
for (const mode of ['always', 'handled'] as const) {
const { container, label, liveInput } = plant()
const release = keepTextFocusThroughTaps(container, mode)
liveInput.focus()
expect(pressKeepsFocus(label), mode).toBe(true)
release()
document.body.innerHTML = ''
}
})
it('lets a tap on nothing pressable dismiss only when taps are handled', () => {
const always = plant()
keepTextFocusThroughTaps(always.container, 'always')
always.liveInput.focus()
expect(pressKeepsFocus(always.gap)).toBe(true)
document.body.innerHTML = ''
const handled = plant()
keepTextFocusThroughTaps(handled.container, 'handled')
handled.liveInput.focus()
expect(pressKeepsFocus(handled.gap)).toBe(false)
})
it('leaves focus alone when no text field holds it, or when the tap is on a text field', () => {
const { container, label, field, liveInput } = plant()
keepTextFocusThroughTaps(container, 'always')
expect(pressKeepsFocus(label)).toBe(false)
liveInput.focus()
expect(pressKeepsFocus(field)).toBe(false)
})
it('does not count a focusable ancestor above the container as a pressable in the bar', () => {
const outer = document.createElement('div')
outer.tabIndex = 0
const { container, gap, liveInput } = plant()
outer.append(container)
document.body.prepend(outer)
keepTextFocusThroughTaps(container, 'handled')
liveInput.focus()
expect(pressKeepsFocus(gap)).toBe(false)
})
it('stops when released', () => {
const { container, label, liveInput } = plant()
keepTextFocusThroughTaps(container, 'always')()
liveInput.focus()
expect(pressKeepsFocus(label)).toBe(false)
})
})
-15
View File
@@ -94,18 +94,3 @@ describe('a recognizer that fails while its start is still resolving', () => {
expect(await server.serve({ action: 'read' })).toMatchObject({ failure: 'failed' })
})
})
describe('a phone speech service too slow to answer', () => {
it('reports busy, not unsupported, so the next dictation asks again', async () => {
const engine: NativeSpeechEngine = {
...engineWith('phone'),
availability: () => Promise.reject(Object.assign(new Error('slow'), { code: 'busy' }))
}
const server = createNativeSpeechServer(engine)
expect(await server.serve({ action: 'status', locale: 'en-US' })).toEqual({
status: 'busy',
locale: null,
preference: 'phone'
})
})
})
@@ -1,12 +0,0 @@
import { describe, expect, it } from 'vitest'
import { orderMobileNewTabAgents } from './mobile-new-tab-agent-options'
describe('mobile new-tab agent options', () => {
it('orders the enabled detected default first', () => {
expect(orderMobileNewTabAgents('codex', ['gemini', 'codex', 'claude'], ['gemini'])).toEqual([
'codex',
'claude'
])
})
})
@@ -1,55 +0,0 @@
import { afterEach, expect, it } from 'vitest'
import { agentSessionFailureSentence } from '../../../src/shared/agent-session/failures/agent-session-failure-words'
import { activateMobileUiLocale } from '../i18n/mobile-i18n'
import { sayMobileAgentSessionFailure } from './agent-session-failure-copy'
afterEach(async () => {
await activateMobileUiLocale('en')
})
it('gives new-chat guidance while keeping a missing conversation diagnostic private', () => {
expect(
agentSessionFailureSentence(
{
kind: 'savedConversationMissing',
detail: { text: 'No conversation found with session ID: private-id', audience: 'log' }
},
'row',
{ agentName: 'Claude' },
sayMobileAgentSessionFailure
)
).toBe("Claude couldn't find this chat's saved conversation. Start a new chat to continue.")
})
it.each([
[
'en',
'OMP has no model selected. Check your model selection and OMP sign-in, then send again.',
"OMP couldn't use @worker_be. Update OMP to 18.1.9 or later to keep it after a restart, or pick another model and send again."
],
[
'de',
'OMP hat kein Modell ausgewählt. Modellauswahl und OMP-Anmeldung prüfen und erneut senden.',
expect.stringContaining('OMP auf 18.1.9 oder neuer aktualisieren')
]
] as const)(
'words a missing OMP model and the update hint on the phone (%s)',
async (locale, none, update) => {
await activateMobileUiLocale(locale)
const say = (fact: Parameters<typeof agentSessionFailureSentence>[0]) =>
agentSessionFailureSentence(
fact,
'rejection',
{ agentName: 'OMP' },
sayMobileAgentSessionFailure
)
expect(say({ kind: 'modelNotSelected' })).toBe(none)
expect(
say({
kind: 'modelUnavailable',
detail: { text: '@worker_be', audience: 'log' },
agentUpdate: '18.1.9'
})
).toEqual(update)
}
)
@@ -19,8 +19,7 @@ import {
sendButton,
permissionAction,
getController,
askAnswer,
getTree
askAnswer
} from './__mocks__/mobile-prompt-controller'
const client: RpcClient = {
@@ -65,18 +64,6 @@ describe('prompt cards through the production controller, send contract and view
}
)
it('shows a collapsed prompt again as a new wait', async () => {
await render({ tab: permissionTab })
act(() => {
getTree().root.findByProps({ accessibilityLabel: 'Collapse' }).props.onPress()
})
await render({
tab: { ...permissionTab, agentStatus: { ...permissionTab.agentStatus, stateStartedAt: 20 } }
})
expect(getController().nativeChatPermission).not.toBe(null)
expect(getController().nativeChatCollapsedPrompt).toBe(null)
})
it('keeps an acknowledged Deny hidden after the chat screen remounts on a lingering status', async () => {
await render({ tab: permissionTab })
await act(async () => {
@@ -28,99 +28,6 @@ describe('mobile structured agent-session launch', () => {
kind: 'unknown'
})
})
it('treats malformed structured responses as unknown', async () => {
const client = clientReturning(
{ ok: true, result: { supported: true } },
{ ok: true, result: { ok: true, value: { sessionId: '' } } }
)
await expect(
createMobileStructuredAgentSession(client, 'workspace-1', 'codex')
).resolves.toMatchObject({
kind: 'unknown'
})
})
it.each(['structured_agent_session_unsupported', 'method_not_found'])(
'treats a top-level %s as a definitive refusal',
async (code) => {
const client = clientReturning(
{ ok: true, result: { supported: true } },
{ ok: false, error: { code, message: 'structured create unavailable' } }
)
await expect(
createMobileStructuredAgentSession(client, 'workspace-1', 'codex')
).resolves.toEqual({
kind: 'failed',
message: 'structured create unavailable'
})
}
)
it.each(['agent_session_operation_unknown', 'runtime_error', 'future_unknown_code'])(
'keeps a top-level %s outcome unknown',
async (code) => {
const client = clientReturning(
{ ok: true, result: { supported: true } },
{ ok: false, error: { code, message: 'create outcome ambiguous' } }
)
await expect(
createMobileStructuredAgentSession(client, 'workspace-1', 'codex')
).resolves.toEqual({
kind: 'unknown',
message: 'create outcome ambiguous'
})
}
)
it('treats an envelope unsupported refusal as definitive', async () => {
const client = clientReturning(
{ ok: true, result: { supported: true } },
{
ok: true,
result: {
ok: false,
refusal: {
code: 'structured_agent_session_unsupported',
message: 'structured create unavailable'
}
}
}
)
await expect(
createMobileStructuredAgentSession(client, 'workspace-1', 'codex')
).resolves.toEqual({
kind: 'failed',
message: 'structured create unavailable'
})
})
it.each(['agent_session_operation_unknown', 'agent_session_ownership_unknown', 'future_code'])(
'keeps an envelope %s refusal unknown',
async (code) => {
const client = clientReturning(
{ ok: true, result: { supported: true } },
{
ok: true,
result: {
ok: false,
refusal: { code, message: 'create outcome ambiguous' }
}
}
)
await expect(
createMobileStructuredAgentSession(client, 'workspace-1', 'codex')
).resolves.toEqual({
kind: 'unknown',
message: 'create outcome ambiguous'
})
}
)
})
it('settles a proven missing-original fork refusal but keeps a lost earlier attempt unknown', async () => {
@@ -1,173 +0,0 @@
import { describe, expect, it } from 'vitest'
import type { AgentJournalDispatchState } from '../../../src/shared/agent-session/journal/agent-session-journal-types'
import type { AgentSessionSendResult } from '../../../src/shared/agent-session/agent-session-wire'
import { DISPATCH_REJECTED_CANCELLED } from '../../../src/shared/agent-session/requests/structured-agent-session-dispatch-rejection'
import { STRUCTURED_AGENT_SESSION_SUBMISSION_MISSING } from '../../../src/shared/agent-session/requests/structured-agent-session-send-evidence'
import { mobileStructuredSendDelivery } from './mobile-structured-send-delivery'
import type { StructuredAgentSessionMutationCallResult } from './mobile-structured-agent-session-rpc'
import { structuredSendResultFixture } from './structured-agent-send-result.test-fixture'
function accepted(
dispatchState: AgentJournalDispatchState,
reason: string | null = null
): StructuredAgentSessionMutationCallResult<AgentSessionSendResult> {
return { status: 'accepted', value: structuredSendResultFixture(dispatchState, reason) }
}
describe('mobileStructuredSendDelivery', () => {
it.each([
['a sign-in rejection', 'Sign in to Grok with `grok login`.', { kind: 'notSignedIn' as const }],
['a content rejection', 'Claude does not support .bmp', undefined],
['a write failure', 'provider_write_failed: broken pipe', undefined]
])('leaves %s to its recorded row', (_name, reason, rejection) => {
const value = structuredSendResultFixture('rejected', reason)
if (rejection && 'submission' in value) {
value.submission.rejection = rejection
}
expect(mobileStructuredSendDelivery({ status: 'accepted', value })).toEqual({
outcome: 'accepted',
error: null
})
})
it('distinguishes transport doubt from an admitted unknown ordinary message', () => {
expect(mobileStructuredSendDelivery({ status: 'unknown' })).toEqual({
outcome: 'unknown',
error: null
})
expect(
mobileStructuredSendDelivery(accepted('unknown', STRUCTURED_AGENT_SESSION_SUBMISSION_MISSING))
).toEqual({ outcome: 'unknown', error: null })
expect(mobileStructuredSendDelivery(accepted('unknown'))).toEqual({
outcome: 'accepted',
error: null
})
})
it.each(['accepted', 'pending'] as const)('reports a written %s send as accepted', (state) => {
expect(mobileStructuredSendDelivery(accepted(state))).toEqual({
outcome: 'accepted',
error: null
})
})
it.each(['waiting', 'dispatched', 'returned'] as const)(
'lets the host own its %s queued message without an optimistic bubble',
(state) => {
expect(
mobileStructuredSendDelivery({
status: 'accepted',
value: {
clientMessageId: 'client-1',
queued: { messageId: 'client-1', position: 1, state }
}
})
).toEqual({ outcome: 'queued', error: null })
}
)
it('hands back a withdrawn card instead of silently sending again', () => {
expect(
mobileStructuredSendDelivery({
status: 'accepted',
value: {
clientMessageId: 'client-1',
queued: { messageId: 'client-1', position: 1, state: 'withdrawn' }
}
})
).toEqual({ outcome: 'rejected', error: 'Message not sent' })
})
it('keeps a handed-off queued message unconfirmed until the stream identifies it', () => {
const value = structuredSendResultFixture('accepted')
if (!('submission' in value)) {
throw new Error('expected a submission answer')
}
expect(
mobileStructuredSendDelivery({
status: 'accepted',
value: {
clientMessageId: 'draft-id',
submission: {
...value.submission,
clientMessageId: 'fresh-id',
queuedMessageId: 'draft-id'
}
}
})
).toEqual({ outcome: 'unknown', error: null })
})
it('fails closed when a malformed answer has no submission', () => {
expect(mobileStructuredSendDelivery({ status: 'accepted', value: JSON.parse('{}') })).toEqual({
outcome: 'unknown',
error: null
})
})
it('lets a kept queued card hold the text after a provider rejection', () => {
const value = structuredSendResultFixture('rejected', 'Orca restarted before this was sent.')
if (!('submission' in value)) {
throw new Error('expected a submission answer')
}
value.submission.keptAsQueuedMessageId = 'card-id'
expect(mobileStructuredSendDelivery({ status: 'accepted', value })).toEqual({
outcome: 'queued',
error: null
})
})
it.each([
{ reason: DISPATCH_REJECTED_CANCELLED, typed: false },
{ reason: 'This message was withdrawn before the agent started it.', typed: true }
])('leaves a stopped submission in its existing chat row (typed $typed)', ({ reason, typed }) => {
const value = structuredSendResultFixture('rejected', reason)
if (typed && 'submission' in value) {
value.submission.rejection = { kind: 'cancelled' }
}
expect(mobileStructuredSendDelivery({ status: 'accepted', value })).toEqual({
outcome: 'accepted',
error: null
})
})
it.each([
['agent_session_operation_invalid', 'Invalid operation'],
['agent_session_checkpoint_stale', 'Fence moved'],
['agent_session_operation_expired', 'Operation expired'],
['agent_session_operation_conflict', 'Operation conflict']
] as const)('reports the current %s refusal', (code, message) => {
expect(
mobileStructuredSendDelivery({
status: 'refused',
code,
message,
failure: { kind: 'refused', code }
})
).toEqual({
outcome: 'rejected',
error: message
})
})
it('preserves an unknown operation refusal as uncertainty', () => {
expect(
mobileStructuredSendDelivery({
status: 'refused',
code: 'agent_session_operation_unknown',
message: 'Outcome unknown',
failure: { kind: 'refused', code: 'agent_session_operation_unknown' }
})
).toEqual({ outcome: 'unknown', error: null })
})
it('reports a request failure without consulting earlier sends', () => {
expect(
mobileStructuredSendDelivery({
status: 'failed',
message: 'Your message was not sent. Send it again.',
failure: { kind: 'failed' }
})
).toEqual({ outcome: 'rejected', error: 'Your message was not sent. Send it again.' })
})
})
@@ -1,76 +0,0 @@
import { describe, expect, it, vi } from 'vitest'
import type { StructuredAgentSessionState } from '../../../../../src/shared/agent-session/structured-agent-session-reducer'
import type { RpcClient } from '../../../transport/rpc/rpc-client-contract'
import { requestMobileStructuredAgentSessionCancel } from '../../mobile-structured-agent-session-cancel'
type SentParams = Record<string, unknown> & { envelope: { clientOperationId: string } }
function recordingClient(sent: SentParams[]): RpcClient {
const sendRequest = async (_method: string, params: SentParams) => {
sent.push(params)
return { ok: true, result: { ok: true, value: { cancelled: true } }, _meta: { runtimeId: 'r' } }
}
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: cancel reaches only `sendRequest`.
return { sendRequest } as unknown as RpcClient
}
function state(turnId: string | null): StructuredAgentSessionState {
const items = turnId
? [
{
itemId: 'status-1',
revision: 1,
sequence: 1,
observedAt: 10,
body: { kind: 'status', text: 'Working', turnLifecycle: { turnId, state: 'running' } }
}
]
: []
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: cancel reads only the fence and the running turn.
return { fence: 3, items } as unknown as StructuredAgentSessionState
}
function press(input: {
sent: SentParams[]
turnId: string | null
hostStopsConversation: boolean | null
prompt?: { itemId: string; expectedRevision: number }
promptCancelSupported?: boolean
}) {
const onSendError = vi.fn()
const pressed = requestMobileStructuredAgentSessionCancel({
client: recordingClient(input.sent),
sessionId: 'session-1',
enabled: true,
stateRef: { current: state(input.turnId) },
promptCancelSupported: input.promptCancelSupported ?? true,
...(input.prompt ? { prompt: input.prompt } : {}),
hostAnswersRepeatedStops: true,
hostStopsConversation: input.hostStopsConversation,
inFlight: new Map(),
onSendError
})
return { pressed, onSendError }
}
describe('phone Stop against a host that stops what the chat has in flight', () => {
it('names no turn while a turn runs either', async () => {
const sent: SentParams[] = []
expect(await press({ sent, turnId: 'turn-1', hostStopsConversation: true }).pressed).toBe(true)
expect(sent[0]).not.toHaveProperty('turnId')
})
it("keeps naming a card's turn when the host cannot take the card's identity", async () => {
const sent: SentParams[] = []
const prompt = { itemId: 'prompt-1', expectedRevision: 2 }
await press({
sent,
turnId: 'turn-1',
hostStopsConversation: true,
prompt,
promptCancelSupported: false
}).pressed
expect(sent[0]).toMatchObject({ turnId: 'turn-1' })
expect(sent[0]).not.toHaveProperty('prompt')
})
})
@@ -1,94 +0,0 @@
// Preserve typed final read refusals beside their words so unreadable history cannot render a sendable composer.
import { createElement } from 'react'
import { act, type ReactTestRenderer } from 'react-test-renderer'
import { createWithQueryClient } from '../../../test-support/query-client-test-renderer'
import { afterEach, beforeEach, expect, it, vi } from 'vitest'
import type { RpcClient } from '../../../transport/rpc/rpc-client-contract'
import { useMobileStructuredAgentSession } from '../../use-mobile-structured-agent-session'
import { CAPABLE, SESSION_ID, ok } from './use-mobile-structured-agent-session-queued.test-fixture'
const asyncStorage = vi.hoisted(() => ({
getItem: vi.fn(async () => null),
setItem: vi.fn(async () => undefined),
removeItem: vi.fn(async () => undefined)
}))
vi.mock('@react-native-async-storage/async-storage', () => ({ default: asyncStorage }))
let renderer: ReactTestRenderer | null = null
let hook: ReturnType<typeof useMobileStructuredAgentSession> | null = null
let listener: ((value: unknown) => void) | null = null
const sendRequest = vi.fn<RpcClient['sendRequest']>()
const client: RpcClient = {
sendRequest,
subscribe: vi.fn<RpcClient['subscribe']>((_method, _params, onData) => {
if (_method === 'agentSession.subscribe') {
listener = onData
}
return vi.fn()
}),
updateTerminalSubscriptionViewport: () => {},
getState: () => 'connected',
getReconnectAttempt: () => 0,
getLastConnectedAt: () => null,
onStateChange: () => () => {},
notifyForeground: () => {},
close: () => {}
}
function Harness(): null {
hook = useMobileStructuredAgentSession({
client,
pairedHostClient: client,
sessionId: SESSION_ID,
sourceIdentity: 'host-a\0workspace-a',
enabled: true,
connected: true,
agent: 'claude',
hostSupport: CAPABLE,
appendComposerText: () => true,
onSendError: vi.fn()
})
return null
}
function refusedRead(reason: string) {
const error = {
code: 'runtime_error',
message: 'agent_session_journal_unreadable',
data: { refusal: { code: 'agent_session_journal_unreadable', details: { reason } } }
}
return { type: 'error', message: error.message, error }
}
async function readFailedWith(reason: string) {
act(() => {
renderer = createWithQueryClient(createElement(Harness))
})
await vi.waitFor(() => expect(listener).toEqual(expect.any(Function)))
act(() => listener?.(refusedRead(reason)))
return hook!.session
}
beforeEach(() => {
vi.clearAllMocks()
sendRequest.mockImplementation(async (method) =>
method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
)
})
afterEach(() => {
act(() => renderer?.unmount())
renderer = null
hook = null
listener = null
})
it('reads a failure that can clear as one the chat keeps trying past', async () => {
expect(await readFailedWith('journalUnavailable')).toMatchObject({
status: 'error',
readFailedFinally: false
})
})
@@ -1,89 +0,0 @@
import { createElement } from 'react'
import { snapshotEvent } from './use-mobile-structured-agent-session-queued.test-fixture'
import { act, type ReactTestRenderer } from 'react-test-renderer'
import { createWithQueryClient } from '../../../test-support/query-client-test-renderer'
import { afterEach, describe, expect, it, vi } from 'vitest'
import type { AgentJournalRenderItem } from '../../../../../src/shared/agent-session/journal/agent-session-journal-types'
import type { AgentSessionSubscribeEvent } from '../../../../../src/shared/agent-session/agent-session-wire'
import type { RpcClient } from '../../../transport/rpc/rpc-client-contract'
import type { RpcResponse } from '../../../transport/rpc/rpc-wire-types'
import { useMobileStructuredAgentSession } from '../../use-mobile-structured-agent-session'
import { ANSWERED_PROMPT_ITEMS } from '../input/mobile-native-chat-answered-prompts.test-fixture'
vi.mock('@react-native-async-storage/async-storage', () => ({
default: { getItem: vi.fn(async () => null), setItem: vi.fn(), removeItem: vi.fn() }
}))
function snapshot(items: AgentJournalRenderItem[]): AgentSessionSubscribeEvent {
return snapshotEvent({ items })
}
describe('useMobileStructuredAgentSession transcript', () => {
let renderer: ReactTestRenderer | null = null
afterEach(() => {
act(() => renderer?.unmount())
renderer = null
})
async function mount(agent: string, items: AgentJournalRenderItem[]) {
let listener: ((value: unknown) => void) | null = null
const client: Pick<RpcClient, 'sendRequest' | 'subscribe' | 'getState' | 'onStateChange'> = {
getState: () => 'connected',
onStateChange: () => () => {},
sendRequest: vi.fn(async (): Promise<RpcResponse> => ({
id: 'response-1',
ok: true,
result: {},
_meta: { runtimeId: 'runtime-1' }
})),
subscribe: vi.fn((_method: string, _params: unknown, onData: (value: unknown) => void) => {
if (_method === 'agentSession.subscribe') {
listener = onData
}
return () => {}
})
}
const rendered: { hook: ReturnType<typeof useMobileStructuredAgentSession> | null } = {
hook: null
}
function Harness(): null {
rendered.hook = useMobileStructuredAgentSession({
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the hook's request, subscription and connection members are provided.
client: client as RpcClient,
pairedHostClient: null,
sessionId: 'session-1',
enabled: true,
connected: true,
hostSupport: null,
agent,
onSendError: vi.fn()
})
return null
}
act(() => {
renderer = createWithQueryClient(createElement(Harness))
})
await vi.waitFor(() => expect(listener).toEqual(expect.any(Function)))
act(() => listener?.(snapshot(items)))
return rendered
}
it('draws an answered approval and question as receipts, never as their raw tool lines', async () => {
const rendered = await mount('claude', ANSWERED_PROMPT_ITEMS)
await vi.waitFor(() => expect(rendered.hook?.session.messages.length).toBeGreaterThan(0))
const { session, receipts } = rendered.hook!
expect(
session.messages.some((message) =>
message.blocks.some(
(block) => block.type === 'tool-call' && block.name === 'AskUserQuestion'
)
)
).toBe(false)
expect(session.messages.flatMap((message) => receipts.get(message.id)?.kind ?? [])).toEqual([
'approval',
'question'
])
})
})
@@ -173,27 +173,6 @@ describe('mobile composer modifier submit in the paired web page', () => {
expect(input.value).toBe('retained draft')
})
it.each([true, false])(
'sends raw text with alternate intent, retaining focus on accepted:%s',
async (accepted) => {
onSend.mockResolvedValue(accepted)
await render()
expect((await key({ metaKey: true })).defaultPrevented).toBe(true)
expect(onSend).toHaveBeenCalledExactlyOnceWith(' hello ', { alternate: true })
expect(document.activeElement).toBe(field())
expect(field().value).toBe(' hello ')
}
)
it('uses Ctrl on Android and leaves Cmd alone', async () => {
vi.spyOn(navigator, 'userAgent', 'get').mockReturnValue('Android')
await render()
expect((await key({ metaKey: true })).defaultPrevented).toBe(false)
expect(onSend).not.toHaveBeenCalled()
expect((await key({ ctrlKey: true })).defaultPrevented).toBe(true)
expect(onSend).toHaveBeenCalledExactlyOnceWith(' hello ', { alternate: true })
})
it.each([
{},
{ shiftKey: true },
@@ -210,30 +189,6 @@ describe('mobile composer modifier submit in the paired web page', () => {
expect(field().value).toBe(' hello ')
})
it('consumes a refused send without changing the draft or focus', async () => {
await render({ sendDisabled: true })
expect((await key({ metaKey: true })).defaultPrevented).toBe(true)
expect(onSend).not.toHaveBeenCalled()
expect(field().value).toBe(' hello ')
expect(document.activeElement).toBe(field())
})
it.each([
{ sendFollowUp: { action: 'queue', offersChoice: true }, alternateSteers: true },
{ sendFollowUp: { action: 'steer', offersChoice: true }, alternateSteers: false },
{ sendFollowUp: { action: 'queue', offersChoice: false }, alternateSteers: false },
{ sendFollowUp: null, alternateSteers: false }
] as const)(
'hands an empty chord to the head card, saying whether its other way is steer: %j',
async ({ sendFollowUp, alternateSteers }) => {
const steerHead = { steers: () => true, run: vi.fn(() => true), light: vi.fn() }
await render({ value: '', sendFollowUp, steerHead })
expect((await key({ metaKey: true })).defaultPrevented).toBe(true)
expect(steerHead.run).toHaveBeenCalledExactlyOnceWith(alternateSteers)
expect(onSend).not.toHaveBeenCalled()
}
)
it('holding Cmd alone on an empty composer shows Steer queued in Send, lights the head card and sends it on a press', async () => {
vi.spyOn(document, 'hasFocus').mockReturnValue(true)
const steerHead = { steers: () => true, run: vi.fn(() => true), light: vi.fn() }
@@ -259,13 +214,6 @@ describe('mobile composer modifier submit in the paired web page', () => {
expect(steerHead.light).toHaveBeenLastCalledWith(false)
})
it('saves a queued edit without alternate intent', async () => {
await render({ editSession: { cancel: vi.fn(), refuseCommand: () => false, locked: false } })
expect((await key({ metaKey: true })).defaultPrevented).toBe(true)
expect(onSend).toHaveBeenCalledExactlyOnceWith(' hello ')
expect(document.activeElement).toBe(field())
})
it.each([
{ value: '@rea', expected: '@README.md ', filePaths: ['README.md', 'src/read.ts'] },
{ value: '/comp', expected: '/compact ', filePaths: [] }
@@ -1,108 +0,0 @@
// @vitest-environment happy-dom
import { act, type ComponentProps } from 'react'
import { createRoot, type Root } from 'react-dom/client'
import type * as ReactNative from 'react-native'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { MobileNativeChatComposer } from './MobileNativeChatComposer'
vi.mock('react-native', () => vi.importActual<typeof ReactNative>('react-native-web'))
vi.mock('./MobileNativeChatComposerField', () => import('./MobileNativeChatComposerField.web'))
vi.mock('../../../platform/keyboard-occlusion', () => ({ useKeyboardOcclusion: () => 0 }))
vi.mock('lucide-react-native', () => ({
Plus: () => null,
AtSign: () => null,
Image: () => null,
Package: () => null,
Paperclip: () => null,
Terminal: () => null
}))
vi.mock('../../../components/ActionSheetModal', () => ({ ActionSheetModal: () => null }))
vi.mock('../input/MobileNativeChatSessionOptionPickers', () => ({
MobileNativeChatSessionOptionPickers: () => null
}))
vi.mock('./MobileNativeChatComposerMic', () => ({ MobileNativeChatComposerMic: () => null }))
vi.mock('./MobileNativeChatContextUsageRing', () => ({
useMobileNativeChatContextRing: () => ({ barProps: {}, ring: null })
}))
vi.mock('./MobileNativeChatSendButton', () => ({ MobileNativeChatSendButton: () => null }))
vi.mock('./MobileNativeChatEditActions', () => ({ MobileNativeChatEditActions: () => null }))
vi.mock('./MobileNativeChatComposerAttachments', () => ({
MobileNativeChatComposerAttachments: () => null
}))
vi.mock('./MobileNativeChatComposerMenu', () => ({
MobileNativeChatComposerSuggestions: () => null
}))
type ComposerProps = ComponentProps<typeof MobileNativeChatComposer>
describe('pasting into the mobile composer in the paired web page', () => {
let root: Root
let container: HTMLDivElement
const onPasteImages = vi.fn()
const onAttachPastedText = vi.fn()
beforeEach(() => {
onPasteImages.mockReset()
onAttachPastedText.mockReset()
container = document.createElement('div')
document.body.append(container)
root = createRoot(container)
})
afterEach(async () => {
await act(async () => root.unmount())
container.remove()
})
async function render(props: Partial<ComposerProps> = {}) {
await act(async () =>
root.render(
<MobileNativeChatComposer
sendSurfaceId="paste-test"
getSendCompletionGeneration={() => 0}
getComposerEditGeneration={() => 0}
value=""
onChangeText={vi.fn()}
onSend={vi.fn()}
onPasteImages={onPasteImages}
structured={{
catalog: { reported: [], conversationCommands: [] },
files: [],
onRemoveFile: vi.fn(),
onSlashMenuOpen: vi.fn(),
onAttachPastedText
}}
{...props}
/>
)
)
}
function paste(text: string, image?: File): Event {
const event = new Event('paste', { bubbles: true, cancelable: true })
Object.defineProperty(event, 'clipboardData', {
value: {
items: image ? [{ type: image.type, getAsFile: () => image }] : [],
files: image ? [image] : [],
getData: (format: string) => (format === 'text/plain' ? text : '')
}
})
const field = container.querySelector('textarea')
if (!field) {
throw new Error('Composer field missing')
}
field.dispatchEvent(event)
return event
}
it('turns a 32 KB paste into a pasted-text file and leaves shorter text to the field', async () => {
await render()
const long = 'a'.repeat(32 * 1024)
expect(paste(long).defaultPrevented).toBe(true)
expect(onAttachPastedText).toHaveBeenCalledExactlyOnceWith(long)
expect(paste(long.slice(1)).defaultPrevented).toBe(false)
expect(onAttachPastedText).toHaveBeenCalledTimes(1)
expect(onPasteImages).not.toHaveBeenCalled()
})
})
@@ -1,4 +1,4 @@
import { createElement, StrictMode, type ComponentProps, type ReactNode } from 'react'
import { createElement, type ComponentProps, type ReactNode } from 'react'
import { act, create, type ReactTestInstance, type ReactTestRenderer } from 'react-test-renderer'
import { Keyboard } from 'react-native'
import { afterEach, describe, expect, it, vi } from 'vitest'
@@ -365,29 +365,6 @@ describe('MobileNativeChatComposer', () => {
expect(input().props.selection).toBeUndefined()
})
it('dismisses an accepted send after Strict Mode replays mount effects', async () => {
vi.mocked(Keyboard.dismiss).mockClear()
await act(async () => {
renderer = create(
createElement(
StrictMode,
null,
createElement(MobileNativeChatComposer, {
value: 'hello',
onChangeText: vi.fn(),
onSend: vi.fn().mockResolvedValue(true),
sendSurfaceId: 'tab-a',
getSendCompletionGeneration: getCurrentSendCompletionGeneration
})
)
)
})
await act(async () => sendButton().props.onPress())
expect(Keyboard.dismiss).toHaveBeenCalledTimes(1)
})
it('does not dismiss a newly focused composer when an old accepted send settles', async () => {
vi.mocked(Keyboard.dismiss).mockClear()
let resolveSend: ((accepted: boolean) => void) | null = null
@@ -1,88 +0,0 @@
import { describe, expect, it, vi } from 'vitest'
import type { RpcClient } from '../../../transport/rpc/rpc-client-contract'
import type { RpcResponse, RpcSuccess } from '../../../transport/rpc/rpc-wire-types'
import { uploadMobileNativeChatImages } from './mobile-native-chat-image-attachment'
function ok(id: string, result: unknown): RpcSuccess {
return { id, ok: true, result, _meta: { runtimeId: 'runtime-1' } }
}
function methodNotFound(id: string): RpcResponse {
return {
id,
ok: false,
error: { code: 'method_not_found', message: 'no' },
_meta: { runtimeId: 'r' }
}
}
function clientWithResponses(responses: RpcResponse[]): Pick<RpcClient, 'sendRequest'> & {
calls: { method: string; params: unknown }[]
} {
const calls: { method: string; params: unknown }[] = []
return {
calls,
sendRequest: vi.fn(async (method: string, params?: unknown) => {
calls.push({ method, params })
const response = responses.shift()
if (!response) {
throw new Error(`unexpected request: ${method}`)
}
return response
})
}
}
describe('uploadMobileNativeChatImages', () => {
it('uploads all three selected images in picker order', async () => {
const client = clientWithResponses([
methodNotFound('start-a'),
ok('save-a', '/tmp/a.png'),
methodNotFound('start-b'),
ok('save-b', '/tmp/b.png'),
methodNotFound('start-c'),
ok('save-c', '/tmp/c.png')
])
const order: string[] = []
async function* pickImages() {
for (const image of [
{ base64: 'AAAA', uri: 'file:///a.jpg' },
{ base64: 'BBBB', uri: 'file:///b.jpg' },
{ base64: 'CCCC', uri: 'file:///c.jpg' }
]) {
order.push(`read:${image.uri}`)
yield image
}
}
const result = await uploadMobileNativeChatImages('library', {
client,
getConnectionId: async () => 'conn-7',
pickImages,
onImageUploaded: (image) => order.push(`uploaded:${image.previewUri}`)
})
expect(result).toEqual([
{
path: '/tmp/a.png',
previewUri: 'file:///a.jpg'
},
{
path: '/tmp/b.png',
previewUri: 'file:///b.jpg'
},
{
path: '/tmp/c.png',
previewUri: 'file:///c.jpg'
}
])
expect(order).toEqual([
'read:file:///a.jpg',
'uploaded:file:///a.jpg',
'read:file:///b.jpg',
'uploaded:file:///b.jpg',
'read:file:///c.jpg',
'uploaded:file:///c.jpg'
])
})
})
@@ -8,7 +8,6 @@ import time
import types
import unittest
from pathlib import Path
from unittest import mock
class FakeKeySynthType:
@@ -44,26 +43,8 @@ runtime = load_runtime()
class RuntimeKeyboardTest(unittest.TestCase):
def setUp(self):
self.events = []
patcher = mock.patch.object(
runtime.Atspi, "generate_keyboard_event", lambda *args: self.events.append(args)
)
patcher.start()
self.addCleanup(patcher.stop)
def test_missing_xdotool_preserves_ascii_and_refuses_unicode(self):
with mock.patch.object(runtime.shutil, "which", return_value=None), mock.patch.dict(
runtime.os.environ, {"XDG_SESSION_TYPE": "x11"}
):
runtime.type_text("Hello")
runtime.press_key("a")
self.assertEqual(self.events, [(0, "Hello", FakeKeySynthType.STRING), (0, "a", FakeKeySynthType.STRING)])
self.events.clear()
with self.assertRaisesRegex(RuntimeError, "unsupported capability"):
runtime.type_text("café Ω")
self.assertEqual(self.events, [])
@unittest.skipIf(sys.platform == "win32", "the Linux bridge uses POSIX termination")
def test_termination_stops_the_typing_child(self):
@@ -112,16 +93,7 @@ class RuntimeKeyboardTest(unittest.TestCase):
except ProcessLookupError:
pass
def run_hotkey(self, raw):
with mock.patch.object(runtime.shutil, "which", return_value="/usr/bin/xdotool"), mock.patch.object(
runtime.subprocess, "run"
) as run:
runtime.hotkey(raw)
return run.call_args.args[0]
def test_hotkey_lowercases_letters_so_xdotool_does_not_add_shift(self):
self.assertEqual(self.run_hotkey("CmdOrCtrl+A"), ["/usr/bin/xdotool", "key", "ctrl+a"])
self.assertEqual(self.run_hotkey("ctrl+shift+T"), ["/usr/bin/xdotool", "key", "ctrl+shift+t"])
@@ -202,18 +202,6 @@ class SnapshotFixture(ExitStack):
class RuntimeRenderTest(unittest.TestCase):
def test_key_requests_reject_missing_payload_without_input(self):
root = FakeAccessible("frame", "Editor")
root.get_state_set = lambda: FakeStateSet(FakeStateType.ACTIVE)
with SnapshotFixture(root), \
patch.object(runtime.Atspi, "generate_keyboard_event", create=True) as keyboard, \
patch.object(runtime.subprocess, "run") as process:
for payload in ({}, {"key": None}, {"key": ""}):
with self.subTest(payload=payload):
with self.assertRaisesRegex(RuntimeError, "key is required"):
runtime.run_operation({"tool": "press_key", "app": "Fixture", "noScreenshot": True, **payload})
keyboard.assert_not_called()
process.assert_not_called()
def test_focus_search_keeps_transient_accessible_wrappers_alive(self):
class TransientNode:
@@ -230,58 +218,7 @@ class RuntimeRenderTest(unittest.TestCase):
self.assertIsNotNone(focused)
self.assertEqual(focused.depth, 30)
def test_snapshot_keeps_semantics_and_image_when_child_geometry_stalls(self):
late = FakeAccessible("button", "Continue")
root = FakeAccessible("frame", "Editor", children=[
FakeAccessible("button", "Healthy"),
*[FakeAccessible("button", f"Slow {i}") for i in range(4)], late,
])
for semantic_delay, stall_children in ((3.1, False), (16, True)):
with self.subTest(semantic_delay=semantic_delay), SnapshotFixture(root) as fixture:
late.read = False
fixture.delays = {root: 1, **{node: 20 if stall_children else 0 for node in root.children[1:-1]}}
def delayed_name():
if not getattr(late, "read", False):
fixture.clock += semantic_delay
late.read = True
return "" if fixture.stalled else "Continue"
late.get_name = delayed_name
late.get_n_actions = lambda: 1
late.get_action_name = lambda _: "click"
snapshot = runtime.make_snapshot("Fixture", True, window_index=0)
self.assertLessEqual(fixture.clock - fixture.captured_at, 3)
self.assertEqual(fixture.timeout, (800, 15000))
elements = snapshot["elements"]
self.assertEqual([item["name"] for item in elements], [root.name, *[n.name for n in root.children]])
self.assertEqual([item["index"] for item in elements], list(range(7)))
self.assertEqual(elements[-1]["runtimeId"], [0, 5])
self.assertEqual(elements[-1]["actions"], ["click"])
self.assertEqual(snapshot["treeLines"][-1], "\t6 button Continue")
self.assertFalse(snapshot["truncation"]["truncated"])
self.assertEqual(snapshot["windowBounds"], fixture.bounds[root].to_json())
self.assertEqual(json.loads(snapshot["screenshotPngBase64"]), fixture.bounds[root].to_json())
self.assertEqual(elements[0]["frame"], runtime.Rect(0, 0, 300, 400).to_json())
self.assertEqual(elements[1]["frame"], runtime.Rect(10, 20, 300, 400).to_json())
self.assertTrue(all((item["frame"] is None) == stall_children for item in elements[2:]))
def test_nonstandard_window_selection_and_fresh_restored_capture(self):
for query, index, delay, restore in (("Fixture", None, 1, False),
("pid:42", 1, 1, False), ("Editor", 1, 0, True)):
with self.subTest(query=query), SnapshotFixture(
FakeAccessible("panel", "Editor", children=[FakeAccessible("button", "Save")])
) as fixture:
root = fixture.root
fixture.app.children.insert(0, FakeAccessible("label", "Unrelated"))
fixture.delays[root] = delay
def move():
fixture.bounds[root] = runtime.Rect(500, 200, 300, 400)
fixture.bounds[root.children[0]] = runtime.Rect(510, 220, 300, 400)
fixture.restore = move
snapshot = runtime.make_snapshot(query, True, window_index=index, restore=restore)
self.assertEqual(snapshot["windowIndex"], 1)
self.assertEqual(snapshot["windowBounds"]["x"], 500 if restore else 100)
self.assertEqual(snapshot["elements"][1]["frame"]["x"], 10)
self.assertEqual(json.loads(snapshot["screenshotPngBase64"]), fixture.bounds[root].to_json())
def test_window_only_protection_preserves_completed_semantic_action(self):
button = FakeAccessible("button", "Continue")
@@ -310,30 +247,6 @@ class RuntimeRenderTest(unittest.TestCase):
runtime.run_operation({"tool": "click", "app": "Fixture"})
self.assertEqual(effects, ["clicked"])
def test_click_activates_the_window_only_for_pointer_fallback(self):
button = FakeAccessible("button", "Continue")
button.get_n_actions = lambda: 1
button.get_action_name = lambda _: "click"
button.do_action = lambda _: True
label = FakeAccessible("label", "Status")
for target, expected_path, expected_calls in (
(button, "accessibility", []),
(label, "synthetic", ["restore", "pointer"]),
):
with self.subTest(path=expected_path), SnapshotFixture(
FakeAccessible("frame", "Editor", children=[button, label])
) as fixture:
calls = []
def restore():
calls.append("restore")
fixture.root.get_state_set = lambda: FakeStateSet(FakeStateType.ACTIVE)
fixture.restore = restore
snapshot = runtime.make_snapshot("Fixture", False)
element = next(item for item in snapshot["elements"] if item["name"] == target.name)
with patch.object(runtime, "click_at", lambda *_: calls.append("pointer")):
result = runtime.run_operation({"tool": "click", "app": "Fixture", "element": element, "noScreenshot": True})
self.assertEqual(result["action"]["path"], expected_path)
self.assertEqual(calls, expected_calls)
def test_pointer_input_waits_for_activation_and_uses_restored_geometry(self):
operations = (
@@ -622,46 +535,6 @@ class RuntimeRenderTest(unittest.TestCase):
indexes = [item["index"] for item in snapshot["elements"]]
self.assertEqual(len(indexes), len(set(indexes)))
def test_geometry_skips_insufficient_budget_and_restores_action_timeout(self):
clock = [0.0]
timeouts = []
def fail():
raise TimeoutError("unresponsive geometry")
with patch.object(runtime.time, "monotonic", side_effect=lambda: clock[0]), \
patch.object(runtime.Atspi, "set_timeout", side_effect=lambda *args: timeouts.append(args), create=True):
reader = runtime.GeometryReader()
clock[0] = 2.96
calls = []
self.assertIsNone(reader.read(lambda: calls.append("called")))
self.assertEqual(calls, [])
self.assertEqual(timeouts, [])
clock[0] = 2.9
self.assertIsNone(reader.read(fail))
self.assertGreaterEqual(timeouts[0][0], 50)
self.assertLessEqual(timeouts[0][0], 100)
self.assertEqual(timeouts[0][1], -1)
self.assertEqual(timeouts[-1], (800, 15000))
def test_wide_labeled_controls_never_enumerate_suppressed_children(self):
roles = (
"button", "check box", "checkbox", "combo box", "heading", "link",
"menu item", "page tab", "push button", "radio button",
)
for role in roles:
with self.subTest(role=role):
root = FakeAccessible(
role, "Save", children=[FakeAccessible("text", str(i)) for i in range(10000)]
)
records, lines, truncation = render(root)
self.assertEqual([item["runtimeId"] for item in records], [[0]])
self.assertEqual(lines, [f"0 {role} Save"])
self.assertEqual(root.counter["child_reads"], 0)
self.assertFalse(truncation["truncated"])
@@ -671,31 +544,9 @@ class RuntimeRenderTest(unittest.TestCase):
def test_node_limit_keeps_exact_prefix_and_truncation(self):
root = FakeAccessible(
"document",
"Results",
children=[FakeAccessible("text", f"Item {index}") for index in range(runtime.MAX_NODES)],
)
records, _, truncation = render(root)
self.assertEqual(len(records), runtime.MAX_NODES)
self.assertEqual(records[-1]["name"], f"Item {runtime.MAX_NODES - 2}")
self.assertTrue(truncation["truncated"])
self.assertFalse(truncation["maxDepthReached"])
def test_depth_limit_keeps_exact_prefix_and_flag(self):
root = FakeAccessible("document", "Depth 65")
for depth in range(runtime.MAX_DEPTH, -1, -1):
root = FakeAccessible("document", f"Depth {depth}", children=[root])
records, _, truncation = render(root)
self.assertEqual(len(records), runtime.MAX_DEPTH + 1)
self.assertEqual(records[-1]["name"], f"Depth {runtime.MAX_DEPTH}")
self.assertTrue(truncation["truncated"])
self.assertTrue(truncation["maxDepthReached"])
if __name__ == "__main__":
@@ -1,35 +0,0 @@
import importlib.util
import sys
import types
import unittest
from pathlib import Path
from unittest import mock
def load_runtime():
editable_text = types.SimpleNamespace(set_text_contents=lambda editable, value: editable.update(text=value) or True)
repository = types.ModuleType("gi.repository")
repository.Atspi = types.SimpleNamespace(EditableText=editable_text)
gi = types.ModuleType("gi")
gi.repository = repository
gi.require_version = lambda *_: None
path = Path(__file__).with_name("runtime.py")
with mock.patch.dict(sys.modules, {"gi": gi, "gi.repository": repository}):
spec = importlib.util.spec_from_file_location("orca_linux_runtime_set_value_test", path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
class SetValueTest(unittest.TestCase):
def test_sets_text_on_bindings_without_is_editable_text(self):
# Why: at-spi2-core < 2.53 (e.g. Ubuntu 24.04) does not expose Accessible.is_editable_text to GI.
editable = {"text": ""}
node = types.SimpleNamespace(get_editable_text_iface=lambda: editable, get_value_iface=lambda: None)
self.assertTrue(load_runtime().set_value(node, "hello"))
self.assertEqual(editable["text"], "hello")
if __name__ == "__main__":
unittest.main()
@@ -1,195 +0,0 @@
$ErrorActionPreference = "Stop"
function Assert-TestEqual($Actual, $Expected, [string]$Label) {
if ($Actual -ne $Expected) {
throw "$Label expected '$Expected', received '$Actual'"
}
}
Add-Type -TypeDefinition @"
using System.Collections;
using System.Collections.Generic;
public sealed class OrcaRenderTestCounter {
public int FindAll;
}
public sealed class OrcaRenderTestBounds {
public bool IsEmpty = true;
public double X;
public double Y;
public double Width;
public double Height;
}
public sealed class OrcaRenderTestControlType {
public string ProgrammaticName = "";
}
public sealed class OrcaRenderTestCurrent {
public string AutomationId = "";
public OrcaRenderTestBounds BoundingRectangle = new OrcaRenderTestBounds();
public string ClassName = "fake";
public OrcaRenderTestControlType ControlType = new OrcaRenderTestControlType();
public bool IsPassword;
public string LocalizedControlType = "";
public string Name = "";
public long NativeWindowHandle;
}
public sealed class OrcaRenderTestPatternCurrent {
public bool IsSelected;
public string Value = "";
}
public sealed class OrcaRenderTestPattern {
public OrcaRenderTestPatternCurrent Current = new OrcaRenderTestPatternCurrent();
}
public sealed class OrcaRenderTestCollection : IEnumerable {
private readonly OrcaRenderTestElement[] values;
public OrcaRenderTestCollection(OrcaRenderTestElement[] values) {
this.values = values;
}
public int Count {
get { return values.Length; }
}
public OrcaRenderTestElement Item(int index) {
return values[index];
}
public IEnumerator GetEnumerator() {
return values.GetEnumerator();
}
}
public sealed class OrcaRenderTestElement {
public readonly List<OrcaRenderTestElement> Children =
new List<OrcaRenderTestElement>();
public OrcaRenderTestCounter Counter = new OrcaRenderTestCounter();
public readonly OrcaRenderTestCurrent Current = new OrcaRenderTestCurrent();
public bool FailFindAll;
public int RuntimeIdValue;
public string ValueText = "";
public OrcaRenderTestCollection FindAll(object scope, object condition) {
Counter.FindAll++;
if (FailFindAll) {
throw new System.InvalidOperationException("defunct node");
}
return new OrcaRenderTestCollection(Children.ToArray());
}
public OrcaRenderTestPattern GetCurrentPattern(object pattern) {
OrcaRenderTestPattern result = new OrcaRenderTestPattern();
result.Current.Value = ValueText;
return result;
}
public int[] GetRuntimeId() {
return new int[] { RuntimeIdValue };
}
public object[] GetSupportedPatterns() {
return new object[0];
}
}
"@
function New-TestCounter {
New-Object -TypeName OrcaRenderTestCounter
}
function New-TestElement {
param(
[string]$Role,
[string]$Name = "",
[string]$Value = "",
[object[]]$Children = @(),
$Counter = $(New-TestCounter),
[switch]$FailFindAll,
[int]$RuntimeId = 1
)
$element = New-Object -TypeName OrcaRenderTestElement
$element.Counter = $Counter
$element.FailFindAll = [bool]$FailFindAll
$element.RuntimeIdValue = $RuntimeId
$element.ValueText = $Value
$element.Current.ControlType.ProgrammaticName = $Role
$element.Current.LocalizedControlType = $Role
$element.Current.Name = $Name
foreach ($child in @($Children)) {
[void]$element.Children.Add($child)
}
$element
}
$operationPath = Join-Path ([IO.Path]::GetTempPath()) ("orca-runtime-render-test-" + [guid]::NewGuid() + ".json")
try {
Set-Content -LiteralPath $operationPath -Encoding UTF8 -Value '{"tool":"handshake"}'
$runtimeOutput = . (Join-Path $PSScriptRoot "runtime.ps1") -OperationPath $operationPath
$handshake = $runtimeOutput | ConvertFrom-Json
Assert-TestEqual $handshake.ok $true "runtime handshake"
$counter = New-TestCounter
$tabs = @()
for ($index = 0; $index -lt 10; $index++) {
$value = if ($index -eq 9) { "1" } else { "" }
$tabs += New-TestElement -Role "tab item" -Name "Tab $index" -Value $value -Counter $counter -RuntimeId ($index + 10)
}
$buttons = @()
for ($index = 0; $index -lt 10; $index++) {
$buttons += New-TestElement -Role "button" -Name "Other $index" -Counter $counter -RuntimeId ($index + 30)
}
$tabList = New-TestElement -Role "tab" -Name "Tabs" -Children $tabs -Counter $counter -RuntimeId 2
$root = New-TestElement -Role "window" -Name "Browser" -Children (@($tabList) + $buttons) -Counter $counter
$tree = Render-OrcaTree $root $null $true
$indexes = @($tree.elements | ForEach-Object { [int]$_.index })
Assert-TestEqual (@($tree.elements | Where-Object { $_.name -eq "Tab 0" }).Count) 0 "compacted inactive tab"
Assert-TestEqual (@($indexes | Sort-Object -Unique).Count) $indexes.Count "compacted browser unique indexes"
$originalMaxNodes = $MaxNodes
try {
$MaxNodes = 3
$counter = New-TestCounter
$children = @()
for ($index = 0; $index -lt 3; $index++) {
$children += New-TestElement -Role "text" -Name "Item $index" -Counter $counter -RuntimeId ($index + 2)
}
$root = New-TestElement -Role "document" -Name "Results" -Children $children -Counter $counter
$tree = Render-OrcaTree $root $null
Assert-TestEqual $tree.elements.Count 3 "node limit record count"
Assert-TestEqual ([string]$tree.elements[-1].name) "Item 1" "node limit prefix"
Assert-TestEqual $tree.truncation.truncated $true "node limit truncation"
Assert-TestEqual $tree.truncation.maxDepthReached $false "node limit depth flag"
} finally {
$MaxNodes = $originalMaxNodes
}
$originalMaxDepth = $MaxDepth
try {
$MaxDepth = 2
$counter = New-TestCounter
$root = New-TestElement -Role "document" -Name "Depth 3" -Counter $counter -RuntimeId 4
for ($depth = 2; $depth -ge 0; $depth--) {
$root = New-TestElement -Role "document" -Name "Depth $depth" -Children @($root) -Counter $counter -RuntimeId ($depth + 1)
}
$tree = Render-OrcaTree $root $null
Assert-TestEqual $tree.elements.Count 3 "depth limit record count"
Assert-TestEqual ([string]$tree.elements[-1].name) "Depth 2" "depth limit prefix"
Assert-TestEqual $tree.truncation.truncated $true "depth limit truncation"
Assert-TestEqual $tree.truncation.maxDepthReached $true "depth limit flag"
} finally {
$MaxDepth = $originalMaxDepth
}
& (Join-Path $PSHOME "powershell.exe") -NoLogo -NoProfile -File (Join-Path $PSScriptRoot "runtime-pointer.test.ps1")
if ($LASTEXITCODE -ne 0) { throw "Windows pointer tests failed" }
Write-Output "windows-snapshot-render-tests-ok"
} finally {
Remove-Item -LiteralPath $operationPath -Force -ErrorAction SilentlyContinue
}
-13
View File
@@ -185,24 +185,11 @@ class ClipboardProtocolTests(unittest.TestCase):
self.assertIsNone(server.source)
self.assertEqual(result.stdout, b"")
def test_missing_display_rejects_without_echoing_text(self):
with tempfile.TemporaryDirectory() as directory:
result = subprocess.run([BINARY], input=b"private text", capture_output=True,
env={**os.environ, "XDG_RUNTIME_DIR": directory, "WAYLAND_DISPLAY": "missing"}, timeout=3)
self.assertEqual(result.returncode, 69)
self.assertNotIn(b"private text", result.stdout + result.stderr)
def test_size_limit_precedes_selection_publication(self):
with DataControlServer("ext_data_control") as server:
self.assertEqual(server.copy(b"x" * (16 * 1024 * 1024 + 1)).returncode, 65)
self.assertIsNone(server.source)
def test_probe_does_not_write(self):
with DataControlServer("ext_data_control") as server:
result = subprocess.run([BINARY, "--probe"], capture_output=True, env=server.environment(), timeout=3)
self.assertEqual(result.returncode, 0)
self.assertIsNone(server.source)
def test_replacement_during_ack_is_success_but_device_loss_is_failure(self):
for event, status in (("cancelled", 0), ("finished", 70), ("seat removal", 70)):
with self.subTest(event=event), DataControlServer("ext_data_control", event) as server:
@@ -121,30 +121,6 @@ function newPurge(db: HarnessDb, closed = () => false, onChange = (): void => {}
})
}
it('persists a high-water mark so later passes skip already-scanned rowids', async () => {
const index = await openSessionSearchHarness('ss-tool-purge-mark')
try {
addSyntheticSession(index.db, { id: 1, text: 'userkept', rows: 300 })
addSyntheticSession(index.db, { id: 2, role: 'tool', text: 'toolremoved', rows: 300 })
const purge = newPurge(index.db)
await purge.request()
expect(countTool(index.db)).toBe(0)
const mark = Number(readMeta(index.db, 'tool_purge_scanned_rowid'))
expect(mark).toBeGreaterThanOrEqual(600)
expect(readMeta(index.db, 'tool_purge_floor_rowid')).toBeUndefined()
// Without the floor trigger, a row below the mark is invisible to later passes: no rescan.
index.db.exec('DROP TRIGGER search_tool_purge_floor')
index.db.exec('DELETE FROM messages WHERE id = 1')
index.db.exec("INSERT INTO messages(id, session_row_id, role) VALUES (1, 1, 'tool')")
await purge.request()
expect(countTool(index.db)).toBe(1)
expect(Number(readMeta(index.db, 'tool_purge_scanned_rowid'))).toBe(mark)
} finally {
await index.close()
}
})
it('purges legacy tool rows written after the mark, including reused tail rowids', async () => {
const index = await openSessionSearchHarness('ss-tool-purge-downgrade')
try {
@@ -1,83 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes'
type VmRow = Partial<EphemeralVmRuntimeRecord>
type MockState = { runtimes: VmRow[]; environmentVm: (VmRow & { workspaceId: string }) | null }
const mocks = vi.hoisted((): MockState => ({ runtimes: [], environmentVm: null }))
vi.mock('../../shared/ephemeral-vm-runtime-store', () => ({
listEphemeralVmRuntimes: () => mocks.runtimes
}))
vi.mock('../../shared/remote-runtime/host-store/runtime-environment-store', () => ({
resolveEnvironment: (_root: string, id: string) => ({ id })
}))
vi.mock('../../shared/ephemeral-vm-environment-sleep', async (importOriginal) => ({
...(await importOriginal<Record<string, unknown>>()),
findEnvironmentEphemeralVmRuntime: () => mocks.environmentVm ?? undefined
}))
import { isRecipeVmEnvironmentAsleep, isRecipeVmSshTargetAsleep } from './recipe-vm-asleep'
import {
registerRecipeVmWaker,
type RecipeVmWaker
} from '../runtime/workspaces/sleep/recipe-vm-waker-registry'
import type { RecipeVmState } from '../runtime/workspaces/sleep/recipe-vm-operations'
function waker(state: (recordSuspended: boolean) => RecipeVmState): RecipeVmWaker {
return {
state: (_workspaceId, recordSuspended) => state(recordSuspended),
noteOpened: vi.fn(),
holdOpen: vi.fn(),
openEnvironment: vi.fn()
}
}
afterEach(() => {
registerRecipeVmWaker(null)
mocks.runtimes = []
mocks.environmentVm = null
})
describe('recipe VM asleep predicate', () => {
it('holds a suspended VM until its wake is under way', () => {
mocks.environmentVm = { id: 'vm-1', workspaceId: 'ws-1', status: 'suspended' }
let waking = false
registerRecipeVmWaker(waker((suspended) => (waking ? 'waking' : suspended ? 'asleep' : 'up')))
expect(isRecipeVmEnvironmentAsleep('/data', 'env-1')).toBe(true)
waking = true
expect(isRecipeVmEnvironmentAsleep('/data', 'env-1')).toBe(false)
})
it('never holds a running VM or an environment no VM serves', () => {
registerRecipeVmWaker(waker((suspended) => (suspended ? 'asleep' : 'up')))
expect(isRecipeVmEnvironmentAsleep('/data', 'env-1')).toBe(false)
mocks.environmentVm = { id: 'vm-1', workspaceId: 'ws-1', status: 'running' }
expect(isRecipeVmEnvironmentAsleep('/data', 'env-1')).toBe(false)
})
it('does not hold a VM whose suspend is still running: a failed suspend leaves it up', () => {
mocks.environmentVm = { id: 'vm-1', workspaceId: 'ws-1', status: 'running' }
registerRecipeVmWaker(waker(() => 'asleep'))
expect(isRecipeVmEnvironmentAsleep('/data', 'env-1')).toBe(false)
})
it('reads the stored record on a host with no waker', () => {
mocks.environmentVm = { id: 'vm-1', workspaceId: 'ws-1', status: 'resume_failed' }
expect(isRecipeVmEnvironmentAsleep('/data', 'env-1')).toBe(true)
})
it('matches a VM to its Orca-owned SSH host and skips every other host', () => {
registerRecipeVmWaker(waker((suspended) => (suspended ? 'asleep' : 'up')))
mocks.runtimes = [
{ id: 'vm-1', workspaceId: 'ws-1', status: 'suspended' },
{ id: 'vm-2', workspaceId: 'ws-2', status: 'running', sshTargetId: 'runtime-ssh-vm-2' },
{ id: 'vm-3', workspaceId: 'ws-3', status: 'cleaned' }
]
expect(isRecipeVmSshTargetAsleep('/data', 'runtime-ssh-vm-1')).toBe(true)
expect(isRecipeVmSshTargetAsleep('/data', 'runtime-ssh-vm-2')).toBe(false)
expect(isRecipeVmSshTargetAsleep('/data', 'runtime-ssh-vm-3')).toBe(false)
expect(isRecipeVmSshTargetAsleep('/data', 'my-own-host')).toBe(false)
})
})
@@ -92,39 +92,6 @@ describe('opening a workspace whose VM host Orca gave up reaching', () => {
mocks.updateStatus.mockClear()
})
it('runs the recipe resume, reconnects the VM and reopens its server', async () => {
vi.useFakeTimers()
state.sshStatus = 'reconnection-failed'
mocks.resume.mockResolvedValue(RESUMED)
await resumeEphemeralVmWorkspace(STORE, 'workspace-1', REQUEST)
await vi.runAllTimersAsync()
expect(mocks.resume).toHaveBeenCalledTimes(1)
expect(mocks.connect).toHaveBeenCalledTimes(1)
expect(mocks.reconnectControl).toHaveBeenCalledWith('env-vm')
expect(mocks.refreshStatus).toHaveBeenCalledWith({ reconnect: true })
})
it('leaves a VM alone while its host answers, is reconnecting, or was never dialed', async () => {
for (const sshStatus of [undefined, 'connected', 'reconnecting', 'connecting'] as const) {
state.sshStatus = sshStatus
await expect(resumeEphemeralVmWorkspace(STORE, 'workspace-1', REQUEST)).resolves.toBe(
state.record
)
}
expect(mocks.resume).not.toHaveBeenCalled()
expect(mocks.connect).not.toHaveBeenCalled()
})
it('leaves a host the user disconnected, and a paired VM, to their own reconnects', async () => {
state.sshStatus = 'reconnection-failed'
await resumeEphemeralVmWorkspace(STORE, 'workspace-1', { ...REQUEST, sshHeld: true })
state.record = { ...UP_RECORD, connectionMode: 'paired', sshTargetId: undefined }
await resumeEphemeralVmWorkspace(STORE, 'workspace-1', REQUEST)
expect(mocks.resume).not.toHaveBeenCalled()
})
it('keeps the record as it was when the recovery fails, so reconnects go on', async () => {
state.sshStatus = 'reconnection-failed'
mocks.resume.mockResolvedValue({
@@ -61,10 +61,4 @@ describe('status probe of a sleeping VM server', () => {
expect(mocks.send).not.toHaveBeenCalled()
expect(mocks.resolveManaged).not.toHaveBeenCalled()
})
it('probes again once the VM is awake', async () => {
mocks.asleep = false
await owner().refresh({ timeoutMs: 1_000 })
expect(mocks.send).toHaveBeenCalledTimes(1)
})
})
@@ -85,18 +85,6 @@ describe('SSH host of a sleeping VM', () => {
expect(created.count).toBe(0)
})
it('connects once the VM is no longer asleep, and never holds other hosts', async () => {
let asleep = true
setSshHostAsleepCheck(() => asleep)
const manager = new SshConnectionManager({ onStateChange: vi.fn() })
// Only Orca-owned VM hosts are ever held.
await expect(manager.connect(target('user-host'))).resolves.toBeDefined()
asleep = false
await expect(manager.connect(target(VM_TARGET_ID))).resolves.toBeDefined()
expect(created.count).toBe(2)
})
it('stops the reconnect ladder, including a retry armed before the sleep', async () => {
vi.useFakeTimers()
let asleep = false
@@ -114,12 +102,4 @@ describe('SSH host of a sleeping VM', () => {
expect(attempts()).toBe(0)
})
it('keeps an unreadable VM record from stranding a host', async () => {
setSshHostAsleepCheck(() => {
throw new Error('store unreadable')
})
const manager = new SshConnectionManager({ onStateChange: vi.fn() })
await expect(manager.connect(target(VM_TARGET_ID))).resolves.toBeDefined()
})
})