test: remove 212 low-value mobile shell and routing tests (#39334)

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
This commit is contained in:
OrcaWin
2026-11-06 23:07:50 -08:00
committed by GitHub
co-authored by OrcaWin
parent 2ed0633a4a
commit f5f45784e2
30 changed files with 6 additions and 3799 deletions
@@ -7,12 +7,6 @@ afterEach(() => {
})
describe.skipIf(!globalThis.orcaRealAgentCliGuard)('vitest real-agent-cli guard', () => {
it('blocks version discovery without treating an absent agent as a test failure', () => {
const result = spawnSync('claude', ['--version'], { encoding: 'utf8', env: process.env })
expect(result.status).toBe(127)
expect(takeRealAgentCliCalls()).toEqual([])
})
it('blocks and records an agent CLI resolved from the inherited PATH', () => {
const result = spawnSync('claude', ['-p', 'hello'], { encoding: 'utf8', env: process.env })
expect(result.status).toBe(127)
@@ -1,20 +0,0 @@
import { describe, expect, it } from 'vitest'
import { selectPrE2eSpecs } from './pr-e2e-source-routing.mjs'
describe('editor host model identity E2E routing', () => {
const spec = 'tests/e2e/editor-model-host-isolation.spec.ts'
it.each([
'src/renderer/src/components/editor/model-lifetime/identity/editor-model-uri.ts',
'src/renderer/src/components/editor/useEditorPanelFileContentLoader.ts',
'src/renderer/src/lib/editor-file-operation-provenance.ts'
])('routes %s', (path) => {
expect(selectPrE2eSpecs([path])).toContain(spec)
})
it('does not route unit tests of those sources', () => {
expect(
selectPrE2eSpecs([
'src/renderer/src/components/editor/model-lifetime/identity/editor-model-uri.test.ts'
])
).not.toContain(spec)
})
})
@@ -1,17 +0,0 @@
import { describe, expect, it } from 'vitest'
import { selectPrE2eSpecs } from './pr-e2e-source-routing.mjs'
describe('CSV preview E2E routing', () => {
it('routes CSV viewer sources, not their unit tests, to the CSV specs', () => {
expect(selectPrE2eSpecs(['src/renderer/src/components/editor/csv/CsvCellValue.tsx'])).toEqual(
expect.arrayContaining([
'tests/e2e/csv-paged-preview.spec.ts',
'tests/e2e/csv-table-editing.spec.ts',
'tests/e2e/csv-url-links.spec.ts'
])
)
expect(
selectPrE2eSpecs(['src/renderer/src/components/editor/csv/csv-parse.test.ts'])
).not.toContain('tests/e2e/csv-url-links.spec.ts')
})
})
@@ -1,21 +0,0 @@
import { describe, expect, it } from 'vitest'
import { selectPrE2eSpecs } from './pr-e2e-source-routing.mjs'
describe('rich Markdown Find routing', () => {
const spec = 'tests/e2e/markdown-find-adversarial.spec.ts'
it.each([
'src/renderer/src/components/editor/rich-markdown/search/rich-markdown-search-focus.ts',
'src/renderer/src/components/editor/rich-markdown/search/RichMarkdownSearchBar.tsx',
'src/renderer/src/components/editor/rich-markdown/instance/RichMarkdownEditorSurface.tsx'
])('routes %s', (file) => {
expect(selectPrE2eSpecs([file])).toContain(spec)
})
it.each([
'src/renderer/src/components/editor/rich-markdown/search/rich-markdown-search-focus.test.ts',
'src/renderer/src/components/editor/rich-markdown/instance/RichMarkdownEditor.tsx'
])('does not route %s', (file) => {
expect(selectPrE2eSpecs([file])).not.toContain(spec)
})
})
@@ -1,24 +0,0 @@
import { describe, expect, it } from 'vitest'
import { selectPrE2eSpecs } from './pr-e2e-source-routing.mjs'
describe('WSL move fence routing', () => {
const spec = 'tests/e2e/wsl-move-fence.spec.ts'
it.each([
'src/main/persistence/moving-wsl-projects/wsl-move-reset.ts',
'src/main/persistence/moving-wsl-projects/wsl-move-scope-guard.ts',
'src/main/ipc/pty/host-env/spawn-cwd.ts',
'src/main/wsl/host-lifecycle/wsl-host-gate.ts',
'src/shared/wsl-move/wsl-move-cutover.ts'
])('routes %s', (file) => {
expect(selectPrE2eSpecs([file])).toContain(spec)
})
it.each([
'src/main/persistence/moving-wsl-projects/wsl-move-reset.test.ts',
'src/main/persistence/moving-wsl-projects/wsl-move-driver.ts',
'src/shared/wsl-move/wsl-move-cutover-extra.ts'
])('does not route %s', (file) => {
expect(selectPrE2eSpecs([file])).not.toContain(spec)
})
})
@@ -1,226 +0,0 @@
import { Buffer } from 'buffer'
import { createElement } from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { describe, expect, it, vi } from 'vitest'
import {
BrowserScreencastOpcode,
type BrowserScreencastFrame
} from '../transport/browser-screencast-protocol'
import type { RpcClient } from '../transport/rpc-client'
import { MobileBrowserPane, type MobileBrowserTab } from './MobileBrowserPane'
import { useBrowserBinaryScreencastGrant } from './use-browser-binary-screencast-grant'
import { findAllByHostType } from '../test-support/react-test-renderer-host-nodes'
// Mock binary-lane negotiation: native always supports it, but older shells may have no encoder behind requested lane (ruling 5).
vi.mock('./use-browser-binary-screencast-grant', () => ({
useBrowserBinaryScreencastGrant: vi.fn(() => true)
}))
vi.mock('./MobileBrowserLoadProgress', () => ({ MobileBrowserLoadProgress: () => null }))
vi.mock('react-native', () => ({
ActivityIndicator: 'ActivityIndicator',
AppState: { currentState: 'active', addEventListener: () => ({ remove: () => {} }) },
Image: 'Image',
PanResponder: { create: () => ({ panHandlers: {} }) },
PixelRatio: { get: () => 2 },
Platform: { OS: 'android' },
Pressable: 'Pressable',
StyleSheet: {
absoluteFillObject: { position: 'absolute', top: 0, left: 0, right: 0, bottom: 0 },
create: (styles: unknown) => styles
},
Text: 'Text',
TextInput: 'TextInput',
View: 'View'
}))
// Mock transitive icons too: Vitest throws on first unmocked export, including view-mode switch.
vi.mock('lucide-react-native', () => ({
ArrowUp: 'ArrowUp',
ChevronLeft: 'ChevronLeft',
ChevronRight: 'ChevronRight',
Monitor: 'Monitor',
RefreshCw: 'RefreshCw',
Smartphone: 'Smartphone'
}))
type Subscription = {
listener: (payload: unknown) => void
onBinaryFrame?: (frame: BrowserScreencastFrame) => void
}
let pageCounter = 0
function makeFrame(): BrowserScreencastFrame {
return {
opcode: BrowserScreencastOpcode.Frame,
seq: 1,
format: 'jpeg',
metadata: { deviceWidth: 360, deviceHeight: 640, pageScaleFactor: 1 },
image: new TextEncoder().encode('frame')
}
}
function spinnerCount(renderer: ReactTestRenderer): number {
return findAllByHostType(renderer.root, 'ActivityIndicator').length
}
async function renderPane(): Promise<{
renderer: ReactTestRenderer
stream: Subscription | undefined
subscriptions: Subscription[]
sendRequest: ReturnType<typeof vi.fn>
}> {
pageCounter += 1
const subscriptions: Subscription[] = []
const sendRequest = vi.fn().mockResolvedValue({})
const client: RpcClient = {
sendRequest,
subscribe: (_method, _params, listener, options) => {
subscriptions.push({ listener, onBinaryFrame: options?.onBinaryFrame })
return () => {}
},
updateTerminalSubscriptionViewport: vi.fn(),
getState: () => 'connected',
getReconnectAttempt: () => 0,
getLastConnectedAt: () => null,
onStateChange: () => () => {},
notifyForeground: vi.fn(),
close: vi.fn()
}
const tab: MobileBrowserTab = {
type: 'browser',
id: `tab-${pageCounter}`,
title: 'Dashboard',
browserWorkspaceId: 'bw-1',
browserPageId: `page-${pageCounter}`,
url: 'https://dashboard.example',
loading: false,
canGoBack: false,
canGoForward: false,
isActive: true
}
const rendered: { renderer?: ReactTestRenderer } = {}
await act(async () => {
rendered.renderer = create(
createElement(MobileBrowserPane, {
client,
// Why: unique worktree id keeps each test on a cold module-level frame cache.
worktreeId: `wt-${pageCounter}`,
tab,
screencastSupported: true,
keyboardLift: 0,
bottomInset: 0,
onToast: () => {}
}),
{ createNodeMock: () => ({ setNativeProps: () => {} }) }
)
await Promise.resolve()
})
const mounted = rendered.renderer
if (!mounted) {
throw new Error('MobileBrowserPane did not mount')
}
const viewport = findAllByHostType(mounted.root, 'View').find(
(node) => typeof node.props.onLayout === 'function'
)
if (!viewport) {
throw new Error('Viewport with onLayout not found')
}
act(() => {
viewport.props.onLayout({ nativeEvent: { layout: { width: 360, height: 640 } } })
})
return { renderer: mounted, stream: subscriptions[0], subscriptions, sendRequest }
}
async function renderStreamingPane(): Promise<{
renderer: ReactTestRenderer
stream: Subscription
sendRequest: ReturnType<typeof vi.fn>
}> {
const { renderer, stream, sendRequest } = await renderPane()
if (!stream) {
throw new Error('browser.screencast subscription not created')
}
return { renderer, stream, sendRequest }
}
function errorMessages(renderer: ReactTestRenderer): string[] {
return findAllByHostType(renderer.root, 'Text').flatMap((node) =>
typeof node.props.children === 'string' ? [node.props.children] : []
)
}
describe('MobileBrowserPane with a stream that reports ready but sends no frames', () => {
// Ready without frames must retain indicator instead of unexplained blank pane.
it('keeps showing the loading indicator instead of an empty black pane', async () => {
const { renderer, stream } = await renderStreamingPane()
act(() => {
stream.listener({ type: 'ready', tab: { url: 'https://dashboard.example' } })
})
expect(spinnerCount(renderer)).toBeGreaterThan(0)
})
it('clears the indicator once real pixels arrive', async () => {
const { renderer, stream } = await renderStreamingPane()
act(() => {
stream.listener({ type: 'ready', tab: { url: 'https://dashboard.example' } })
})
act(() => {
stream.onBinaryFrame?.(makeFrame())
})
expect(spinnerCount(renderer)).toBe(0)
expect(errorMessages(renderer)).not.toContain(
'Update the Orca app to stream browser tabs here.'
)
const source = findAllByHostType(renderer.root, 'Image')
.map((image) => (image.props.source as { uri?: string } | null)?.uri)
.find((uri) => typeof uri === 'string')
expect(source).toContain(Buffer.from(makeFrame().image).toString('base64'))
})
})
describe('MobileBrowserPane against a shell with no binary screencast lane', () => {
// Grant is negotiation: subscribing without encoder yields no frames until startup timeout (ruling 5).
it('never subscribes, and says so with the stream-error state it already has', async () => {
vi.mocked(useBrowserBinaryScreencastGrant).mockReturnValue(false)
try {
const { renderer, subscriptions } = await renderPane()
expect(subscriptions).toEqual([])
expect(errorMessages(renderer)).toContain('Update the Orca app to stream browser tabs here.')
} finally {
vi.mocked(useBrowserBinaryScreencastGrant).mockReturnValue(true)
}
})
})
describe('MobileBrowserPane frame acks', () => {
// Old hosts strip the opt-in and would refuse the unknown ack method.
it('acks received frames only after ready echoes frameAck', async () => {
const legacy = await renderStreamingPane()
act(() => {
legacy.stream.listener({ type: 'ready', subscriptionId: 'sub-legacy', tab: {} })
legacy.stream.onBinaryFrame?.(makeFrame())
})
expect(legacy.sendRequest).not.toHaveBeenCalled()
const credited = await renderStreamingPane()
act(() => {
credited.stream.listener({ type: 'ready', subscriptionId: 'sub-1', frameAck: true, tab: {} })
credited.stream.onBinaryFrame?.(makeFrame())
})
expect(credited.sendRequest).toHaveBeenCalledWith('browser.screencast.ack', {
worktree: `id:wt-${pageCounter}`,
subscriptionId: 'sub-1',
seq: 1
})
})
})
@@ -53,10 +53,6 @@ vi.mock('../transport/host-descriptor-recorder', () => ({
recordHostDescriptorFromStatus: vi.fn()
}))
function clientWithStatus(result: Record<string, unknown>): RpcClient {
return { sendRequest: vi.fn().mockResolvedValue({ ok: true, result }) } as unknown as RpcClient
}
function GateConsumer() {
const { hostCapabilities } = useHostProtocolGates()
return createElement('GateStatus', null, hostCapabilities.join(','))
@@ -114,78 +110,6 @@ describe('HostProtocolGate', () => {
vi.restoreAllMocks()
})
it('replaces the host UI with the block screen when mobile is too old', async () => {
// Why: blocked warns to console; keep test output clean without hiding other errors.
vi.spyOn(console, 'warn').mockImplementation(() => {})
hostClient.current = {
client: clientWithStatus({ protocolVersion: 5, minCompatibleMobileVersion: 999 }),
state: 'connected'
}
renderer = await renderGate()
const output = renderedText(renderer)
expect(output).toContain('Update Orca Mobile')
expect(output).toContain('Open App Store')
expect(output).not.toContain('HostContent')
})
it('routes Android mobile updates to GitHub Releases', async () => {
vi.spyOn(console, 'warn').mockImplementation(() => {})
nativeTestState.platform.OS = 'android'
hostClient.current = {
client: clientWithStatus({ protocolVersion: 5, minCompatibleMobileVersion: 999 }),
state: 'connected'
}
renderer = await renderGate()
const output = renderedText(renderer)
expect(output).toContain('Update Orca Mobile')
expect(output).toContain('Update Orca Mobile from GitHub Releases')
expect(output).toContain('Open GitHub Releases')
expect(output).not.toContain('mobile app store')
expect(output).not.toContain('HostContent')
const [openReleases] = findAllByHostType(renderer.root, 'Pressable')
act(() => openReleases?.props.onPress())
expect(nativeTestState.openUrl).toHaveBeenCalledWith(
'https://github.com/stablyai/orca/releases'
)
})
it('replaces the host UI with the block screen when desktop is too old', async () => {
vi.spyOn(console, 'warn').mockImplementation(() => {})
hostClient.current = {
client: clientWithStatus({ protocolVersion: 0, minCompatibleMobileVersion: 0 }),
state: 'connected'
}
renderer = await renderGate()
const output = renderedText(renderer)
expect(output).toContain('Update Orca on your computer')
expect(output).toContain('Open GitHub Releases')
expect(output).not.toContain('HostContent')
})
it('renders the host UI when the verdict is ok', async () => {
const client = clientWithStatus({
protocolVersion: 5,
minCompatibleMobileVersion: 0,
capabilities: ['browser.screencast.v1']
})
hostClient.current = {
client,
state: 'connected'
}
renderer = await renderGate()
const output = renderedText(renderer)
expect(output).toContain('HostContent')
expect(output).toContain('browser.screencast.v1')
expect(output).not.toContain('Update Orca')
expect(client.sendRequest).toHaveBeenCalledOnce()
})
it('renders the host UI while the host connection is still pending', async () => {
hostClient.current = { client: null, state: 'connecting' }
renderer = await renderGate()
expect(renderedText(renderer)).toContain('HostContent')
})
it('does not mount host routes before a connected host passes the compatibility probe', async () => {
const client = {
sendRequest: vi.fn().mockReturnValue(new Promise(() => {}))
@@ -249,65 +173,4 @@ describe('HostProtocolGate', () => {
)
expect(overlay?.props.pointerEvents).toBe('auto')
})
it('still replaces mounted routes when the verdict comes back blocked', async () => {
vi.spyOn(console, 'warn').mockImplementation(() => {})
hostClient.current = { client: null, state: 'connecting' }
renderer = await renderGate()
expect(renderedText(renderer)).toContain('HostContent')
await act(async () => {
hostClient.current = {
client: clientWithStatus({ protocolVersion: 5, minCompatibleMobileVersion: 999 }),
state: 'connected'
}
renderer?.update(gateElement())
await Promise.resolve()
})
const output = renderedText(renderer)
expect(output).toContain('Update Orca Mobile')
expect(output).not.toContain('HostContent')
})
it('keeps an already-validated host route mounted while reconnect status is pending', async () => {
const client = {
sendRequest: vi
.fn()
.mockResolvedValueOnce({
ok: true,
result: { protocolVersion: 5, minCompatibleMobileVersion: 0 }
})
.mockReturnValueOnce(new Promise(() => {}))
} as unknown as RpcClient
hostClient.current = { client, state: 'connected' }
renderer = await renderGate()
await act(async () => {
hostClient.current = { client, state: 'disconnected' }
renderer?.update(gateElement())
})
await act(async () => {
hostClient.current = { client, state: 'connected' }
renderer?.update(gateElement())
await Promise.resolve()
})
const output = renderedText(renderer)
expect(output).toContain('HostContent')
// Why: the host already answered once, so a reconnect probe must not dim the UI it validated.
expect(output).not.toContain('Checking host compatibility')
expect(client.sendRequest).toHaveBeenCalledTimes(2)
})
it('fails open when a connected host cannot answer the status probe', async () => {
hostClient.current = {
client: {
sendRequest: vi.fn().mockResolvedValue({ ok: false, error: { message: 'unavailable' } })
} as unknown as RpcClient,
state: 'connected'
}
renderer = await renderGate()
expect(renderedText(renderer)).toContain('HostContent')
})
})
@@ -1,139 +0,0 @@
// @vitest-environment happy-dom
import React, { act } from 'react'
import { createRoot, type Root } from 'react-dom/client'
import { afterEach, expect, it, vi } from 'vitest'
import { MobilePrTabSheets } from './MobilePrTabSheets'
import type { MobilePrTab, PrTabSheetRequest } from './use-mobile-pr-tab'
type Field = { value: string; onChangeText: (value: string) => void }
const io = vi.hoisted(() => ({
load: vi.fn(),
fields: new Map<string, Field>()
}))
vi.mock('react-native', () => ({
StyleSheet: { create: <T,>(styles: T) => styles, hairlineWidth: 1 },
View: ({ children }: React.PropsWithChildren) => <div>{children}</div>,
Text: ({ children }: React.PropsWithChildren) => <span>{children}</span>,
ActivityIndicator: () => <span role="progressbar" />,
Pressable: ({ children }: React.PropsWithChildren) => <div>{children}</div>
}))
vi.mock('lucide-react-native', () => ({
ChevronsUpDown: () => null,
GitMerge: () => null,
Sparkles: () => null
}))
// The drawer finishes its hide at once, so a closed sheet unmounts as it does on the phone.
vi.mock('../bottom-drawer/mounted-bottom-drawer', async () => {
const { useLayoutEffect } = await import('react')
return {
MountedBottomDrawer: ({
visible,
children,
onHidden
}: React.PropsWithChildren<{ visible: boolean; onHidden: () => void }>) => {
useLayoutEffect(() => {
if (!visible) {
onHidden()
}
}, [visible, onHidden])
return <div>{children}</div>
}
}
})
vi.mock('../composer-input/FieldTextInput', () => ({
FieldTextInput: (props: Field & { accessibilityLabel?: string }) => {
io.fields.set(props.accessibilityLabel ?? '', props)
return null
}
}))
vi.mock('../nav-bar/SheetHeader', () => ({ SheetHeader: () => null }))
vi.mock('../SheetPrimaryButton', () => ({ SheetPrimaryButton: () => null }))
vi.mock('../list/ListGroup', () => ({ ListGroup: () => null, ListRow: () => null }))
vi.mock('../MobileSwitch', () => ({ MobileSwitch: () => null }))
vi.mock('../ConfirmModal', () => ({ ConfirmModal: () => null }))
vi.mock('./PrReviewersSheet', () => ({ PrReviewersSheet: () => null }))
vi.mock('./PrBasePicker', () => ({ PrBasePicker: () => null }))
vi.mock('../../source-control/MobileCommitFailurePanel', () => ({
MobileCommitFailurePanel: () => null
}))
vi.mock('../../source-control/use-mobile-commit-failure-recovery', () => ({
useMobileCommitFailureRecovery: () => ({})
}))
vi.mock('../../source-control/mobile-pr-create-draft', () => ({
loadMobilePrCreateDraft: io.load,
generateMobilePrFields: vi.fn(),
cancelMobilePrFields: vi.fn()
}))
vi.mock('expo-router', () => ({ useFocusEffect: () => {} }))
vi.mock('../../theme/use-mobile-color-scheme', () => ({ useMobileColorScheme: () => 'dark' }))
vi.mock('../../i18n/use-mobile-translation', () => ({
useMobileTranslation: () => (_key: string, fallback: string) => fallback
}))
let root: Root | null = null
afterEach(() => {
act(() => root?.unmount())
root = null
io.fields.clear()
io.load.mockReset()
})
function seed(title: string) {
return { prefill: { provider: 'github' }, title, body: '', base: 'main' }
}
function render(gitBranch: string, sheetRequest: PrTabSheetRequest | null) {
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: carries every MobilePrTab member the sheets and Create read.
const tab = {
client: {},
worktreeId: 'wt-1',
gitBranch,
gitStatus: null,
commitsAhead: 2,
creatingPr: false,
setCreatingPr: () => {},
state: { kind: 'none' },
confirm: null,
sheetRequest,
sheetInScope: () => true,
closeSheet: () => {},
onSheetAfterClose: () => {}
} as unknown as MobilePrTab
act(() => root!.render(<MobilePrTabSheets tab={tab} />))
}
function createRequest(id: number): PrTabSheetRequest {
return {
kind: 'createPr',
scope: { client: null, worktreeId: 'wt-1', branch: 'feature/a', resource: null },
id
}
}
async function settle() {
await act(async () => {})
}
it('reopens Create PR on the same branch with the typed title, and seeds another branch from its commits', async () => {
root = createRoot(document.createElement('div'))
io.load.mockImplementation(async (_client: unknown, _wt: string, input: { branch: string }) =>
seed(input.branch === 'feature/a' ? 'Seeded from a' : 'Seeded from b')
)
render('feature/a', createRequest(1))
await settle()
act(() => io.fields.get('Title')!.onChangeText('My typed title'))
render('feature/a', null)
io.fields.clear()
render('feature/a', createRequest(2))
await settle()
expect(io.fields.get('Title')!.value).toBe('My typed title')
render('feature/a', null)
io.fields.clear()
render('feature/b', createRequest(3))
await settle()
expect(io.fields.get('Title')!.value).toBe('Seeded from b')
})
@@ -1,4 +1,3 @@
import { randomBytes } from 'node:crypto'
import { describe, expect, it, vi } from 'vitest'
vi.mock('expo-file-system', () => ({ Directory: class {}, File: class {}, Paths: {} }))
@@ -14,7 +13,6 @@ import {
FAKE_GENERATION_ROOT,
type FakeGenerationFileSystem
} from '../mobile-web-shell/generation-file-system-fake'
import { deriveHostCacheKey } from '../mobile-web-shell/host-cache-key'
import { createDeviceStore, type DeviceStoreOptions } from './device-store'
import { deviceStoreRows } from './device-store-files'
import type { DeviceStoreKeychain } from './device-store-key'
@@ -54,71 +52,6 @@ const rowUri = (hostId: string, table: 'cache' | 'draft', key: string): string =
deviceStoreRows(ROOTS, hostId, table, [key])[0]!.uri
describe('device store', () => {
it('evicts least-recently-used cache rows past the cap across a relaunch and never touches drafts', async () => {
vi.useFakeTimers({ toFake: ['Date'] })
const fileSystem = createFakeGenerationFileSystem()
const keychain = memoryKeychain()
const firstLaunch = storeOn(fileSystem, { keychain })
await firstLaunch.runLaunchMaintenance()
for (let draft = 0; draft < 3; draft += 1) {
await firstLaunch.write('host-a', 'draft', [
{ key: `draft-${draft}`, value: base64('typed') }
])
}
// 512 KiB encoded seals to 393,244 bytes, so the 342nd row crosses 128 MiB and eviction keeps 307.
const value = randomBytes(393_216).toString('base64')
const writeRow = async (target: typeof firstLaunch, row: number) => {
vi.setSystemTime(1_000_000 + row)
expect(await target.write('host-a', 'cache', [{ key: `row-${row}`, value }])).toEqual({
written: true
})
}
for (let row = 0; row < 300; row += 1) {
await writeRow(firstLaunch, row)
}
// The next launch learns the first 300 rows only from its seed.
const store = storeOn(fileSystem, { keychain })
await store.runLaunchMaintenance()
for (let row = 300; row < 350; row += 1) {
await writeRow(store, row)
}
vi.useRealTimers()
const cache = await store.read('host-a', 'cache', ['row-0', 'row-34', 'row-35', 'row-349'])
expect(cache.status === 'ok' && cache.values.map((v) => v !== null)).toEqual([
false,
false,
true,
true
])
expect(await store.read('host-a', 'draft', ['draft-0', 'draft-1', 'draft-2'])).toEqual({
status: 'ok',
values: [base64('typed'), base64('typed'), base64('typed')]
})
})
it('leaves no file of a removed host, whether wiped directly or swept at the next launch', async () => {
const fileSystem = createFakeGenerationFileSystem()
const keychain = memoryKeychain()
const store = storeOn(fileSystem, { keychain })
for (const hostId of ['host-a', 'host-b', 'host-c']) {
await store.write(hostId, 'cache', [{ key: 'hosts', value: base64(hostId) }])
await store.write(hostId, 'draft', [{ key: 'draft', value: base64(hostId) }])
}
await store.wipeHost('host-a')
const hostPaths = (hostId: string) =>
fileSystem.paths().filter((path) => path.includes(deriveHostCacheKey(hostId)))
expect(hostPaths('host-a')).toEqual([])
// Relaunch with host-c missing from the stored host list.
const relaunched = storeOn(fileSystem, { keychain })
await relaunched.runLaunchMaintenance()
expect(hostPaths('host-c')).toEqual([])
expect(await relaunched.read('host-b', 'draft', ['draft'])).toEqual({
status: 'ok',
values: [base64('host-b')]
})
})
it('wipes and remints when the key is gone but files remain', async () => {
const fileSystem = createFakeGenerationFileSystem()
await storeOn(fileSystem).write('host-a', 'draft', [{ key: 'draft', value: base64('x') }])
@@ -32,23 +32,6 @@ const TEMPLATE = `android {
`
describe('android-release-signing plugin', () => {
it('signs release builds through the env-driven release config', () => {
const patched = patchAppBuildGradle(TEMPLATE)
expect(patched).toContain('storeFile file(orcaKeystorePath)')
expect(patched).toContain('enableV3Signing = true')
expect(patched).toContain('signingConfig orcaReleaseSigningConfig(signingConfigs)')
expect(patched).toContain("System.getenv('ORCA_ANDROID_REQUIRE_RELEASE_SIGNING') == 'true'")
// Debug builds keep the debug key; only the release build type changes.
expect(patched.match(/signingConfig signingConfigs\.debug/g)).toHaveLength(1)
expect(patched).not.toMatch(/storePassword '(?!android')/)
})
it('is idempotent across repeated prebuilds', () => {
const once = patchAppBuildGradle(TEMPLATE)
expect(patchAppBuildGradle(once)).toBe(once)
})
it('fails prebuild when the template no longer matches', () => {
const changed = TEMPLATE.replace(
/(release \{[\s\S]*?)signingConfig signingConfigs\.debug/,
@@ -24,444 +24,26 @@ vi.mock('../app-update/use-wall-app-update', mocks['../app-update/use-wall-app-u
vi.mock('../transport/host-client-hooks', mocks['../transport/host-client-hooks'])
vi.mock('./use-page-host-snapshot', mocks['./use-page-host-snapshot'])
vi.mock('./use-mobile-web-shell-session', mocks['./use-mobile-web-shell-session'])
import { createElement } from 'react'
import { act, create } from 'react-test-renderer'
import { bridgeId, clientFrame, createFakeRpcClient } from './bridge-host-test-fakes'
import { act } from 'react-test-renderer'
import {
byName,
trackRenderedScreen,
SCREEN_BUILD_ID as BUILD_ID,
SCREEN_DIRECTORY as DIRECTORY,
readyState,
renderScreen as mountScreen,
textOf,
updateScreen as reRenderScreen
textOf
} from './mobile-web-shell-screen-test-harness'
import { BRIDGE_BACK_CLAIM_NOTIFY } from './bridge/bridge-page-back'
import { BRIDGE_PAGE_PAINTED } from './bridge/bridge-page-painted'
import {
BRIDGE_FAULT_GRANT,
BRIDGE_NAVIGATE_BACK_NOTIFY,
readBridgeHostMessage
} from './bridge/bridge-envelope'
import { MobileWebShellScreen } from './MobileWebShellScreen'
import type { MobileWebShellSessionState } from './mobile-web-shell-session-contract'
import type { ReactTestInstance, ReactTestRenderer } from 'react-test-renderer'
const fetching = (receivedBytes: number, totalBytes: number): MobileWebShellSessionState => ({
kind: 'fetching',
completedAssets: 0,
totalAssets: 128,
receivedBytes,
totalBytes
})
function fillScaleOf(tree: ReactTestRenderer): unknown {
return fillOf(tree).value
}
function fillOf(tree: ReactTestRenderer): { readonly value: unknown } {
const bar = tree.root.find(
(node) => node.props.testID === 'mobile-web-shell-progress-bar' && String(node.type) === 'View'
)
const [fill] = bar.findAll((node) => String(node.type) === 'Animated.View')
return fill.props.style[1].transform[0].scaleX
}
const renderScreen = (state: MobileWebShellSessionState): Promise<ReactTestRenderer> =>
mountScreen(MobileWebShellScreen, dependencies, state)
const updateScreen = (tree: ReactTestRenderer, state: MobileWebShellSessionState): Promise<void> =>
reRenderScreen(MobileWebShellScreen, dependencies, tree, state)
afterEach(harness.unmountRenderedScreens)
beforeEach(() => {
harness.resetScreenDependencies(dependencies)
})
describe('the hybrid shell screen', () => {
it('moves the fill with the download feed, without a render to carry it', async () => {
const tree = await renderScreen(fetching(2_020_592, 8_082_368))
expect(fillScaleOf(tree)).toBe(0.25)
dependencies.downloadProgress.publish(0.5)
expect(fillScaleOf(tree)).toBe(0.5)
expect(textOf(tree)).toContain('2.0 of 8.1 MB')
})
it('starts one ease per window toward the latest value, and lands full at once', async () => {
const tree = await renderScreen(fetching(0, 8_082_368))
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] })
try {
dependencies.downloadProgress.publish(0.1)
dependencies.downloadProgress.publish(0.2)
dependencies.downloadProgress.publish(0.3)
expect(fillScaleOf(tree)).toBe(0.1)
vi.advanceTimersByTime(50)
expect(fillScaleOf(tree)).toBe(0.3)
dependencies.downloadProgress.publish(0.4)
dependencies.downloadProgress.publish(1)
expect(fillScaleOf(tree)).toBe(1)
} finally {
vi.useRealTimers()
}
})
it('starts nothing after unmount for a value still waiting on its window', async () => {
const tree = await renderScreen(fetching(0, 8_082_368))
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] })
try {
dependencies.downloadProgress.publish(0.1)
dependencies.downloadProgress.publish(0.5)
const fill = fillOf(tree)
act(() => tree.unmount())
vi.advanceTimersByTime(50)
expect(fill.value).toBe(0.1)
} finally {
vi.useRealTimers()
}
})
it('delivers an init through the ready view bridge', async () => {
dependencies.client = createFakeRpcClient()
const tree = await renderScreen(readyState('session-one'))
const view = byName(tree, 'ShellViewProbe')[0]
expect(view.props.bridgeEnabled).toBe(true)
await act(async () =>
view.props.onBridgeMessage({ nativeEvent: { json: clientFrame({ type: 'ready' }) } })
)
expect(dependencies.posted.map((raw) => readBridgeHostMessage(raw))).toContainEqual({
ok: true,
message: expect.objectContaining({
type: 'init',
sessionId: 'session-one',
host: expect.objectContaining({ id: 'host-1' })
})
})
})
it('rebuilds the view rather than updating it when the session id changes', async () => {
const tree = await renderScreen(readyState('session-one'))
await updateScreen(tree, readyState('session-two'))
expect(dependencies.lifecycle).toEqual([
'mount:session-one',
'unmount:session-one',
'mount:session-two'
])
})
it('forwards a failure the native view reports and drops a payload it cannot read', async () => {
const tree = await renderScreen(readyState('session-one'))
const view = byName(tree, 'ShellViewProbe')[0]
await act(async () => {
view.props.onLoadState({ nativeEvent: { state: 'ready' } })
view.props.onLoadState({ nativeEvent: { state: 'failed', reason: 'invented' } })
view.props.onLoadState({ nativeEvent: { state: 'failed', reason: 'render-process-gone' } })
})
expect(dependencies.reportShellFailure.mock.calls).toEqual([['render-process-gone']])
})
it('requests an app-store refresh on every ready ask', async () => {
dependencies.client = createFakeRpcClient()
const tree = await renderScreen(readyState('session-one'))
const view = byName(tree, 'ShellViewProbe')[0]
const refreshesBeforeReady = dependencies.storageRefreshes
await act(async () => {
view.props.onBridgeMessage({ nativeEvent: { json: clientFrame({ type: 'ready' }) } })
view.props.onBridgeMessage({ nativeEvent: { json: clientFrame({ type: 'ready' }) } })
})
// A document that reloads inside one mount asks again; a refresh per ask is what lets a key
// the app changed meanwhile reach the `init` after it.
expect(dependencies.storageRefreshes - refreshesBeforeReady).toBe(2)
})
// Observe wire frames only; ruling 34 leaves delivery untracked and one-shot consumption to the page.
async function renderForRoute(params: Record<string, string>): Promise<{
tree: ReactTestRenderer
initRoutes: () => (Record<string, string> | undefined)[]
move: (next: Record<string, string>) => Promise<void>
ready: () => Promise<void>
}> {
const element = (next: Record<string, string>) =>
createElement(MobileWebShellScreen, {
hostId: 'host-1',
route: { pathname: '/h/host-1', params: next }
})
dependencies.state = readyState('session-one')
const rendered: { tree: ReactTestRenderer | null } = { tree: null }
await act(async () => {
rendered.tree = create(element(params))
})
const tree = rendered.tree
if (tree === null) {
throw new Error('screen did not render')
}
trackRenderedScreen(tree)
return {
tree,
// Parse with the page’s reader so rejected frames cannot inflate init counts.
initRoutes: () =>
dependencies.posted
.map((json) => readBridgeHostMessage(json))
.flatMap((read) => (read.ok && read.message.type === 'init' ? [read.message] : []))
.map((frame) => frame.route?.params),
move: async (next) => {
await act(async () => {
tree.update(element(next))
})
},
ready: async () => {
await act(async () => {
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
})
}
}
}
// Send once per route change; the next ready repairs missed delivery using the current route, without tracking acknowledgements (rulings 33.1/34).
it('posts one init for a route that moved, and none for a render that moved nothing', async () => {
dependencies.client = createFakeRpcClient()
const page = await renderForRoute({ paneKey: '' })
await page.ready()
expect(page.initRoutes()).toEqual([{ paneKey: '' }])
await page.move({ paneKey: 'pane-1' })
expect(page.initRoutes()).toEqual([{ paneKey: '' }, { paneKey: 'pane-1' }])
await page.move({ paneKey: 'pane-1' })
expect(page.initRoutes()).toHaveLength(2)
})
it('answers every ask with the route it holds then, which is how a lost frame is repaired', async () => {
dependencies.client = createFakeRpcClient()
dependencies.postFails = true
const warned = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
const page = await renderForRoute({ paneKey: '' })
await page.ready()
await page.move({ paneKey: 'pane-1' })
expect(dependencies.posted).toHaveLength(2)
dependencies.postFails = false
await page.ready()
expect(page.initRoutes().at(-1)).toEqual({ paneKey: 'pane-1' })
warned.mockRestore()
})
// Client replacement rebuilds the host without changing the page session; seed it from reducer state because the page does not handshake again.
it('serves a page whose session handshook before this host was built', async () => {
const client = createFakeRpcClient()
dependencies.client = client
dependencies.pageReady = true
const tree = await renderScreen(readyState('session-one'))
// No new ready arrives from a page that was never told its host changed.
await act(async () => {
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: {
json: clientFrame({ type: 'request', id: bridgeId(1), method: 'status.get' })
}
})
})
expect(client.requests.map((request) => request.method)).toEqual(['status.get'])
})
it('reports a ready page fault as a document-load failure', async () => {
dependencies.client = createFakeRpcClient()
const warned = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
const tree = await renderScreen(readyState('session-one'))
await act(async () => {
// Only an established session receives the fault grant.
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: {
json: clientFrame({
type: 'notify',
name: BRIDGE_FAULT_GRANT,
error: { category: 'Error', message: 'the route threw', isRpcDeliveryUnknown: false }
})
}
})
})
expect(dependencies.reportShellFailure.mock.calls).toEqual([['document-load-failed']])
warned.mockRestore()
})
it('reports a URL nothing on this phone could open, which is the dead tap that survives', async () => {
dependencies.client = createFakeRpcClient()
const failure = new Error('no activity found')
// Create rejection per call; constructing it before the frame arrives would leave it temporarily unhandled.
dependencies.openUrl.mockImplementation(() => Promise.reject(failure))
const warned = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
const tree = await renderScreen(readyState('session-one'))
await act(async () => {
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: {
json: clientFrame({
type: 'notify',
name: 'externalLink',
url: 'mailto:someone@example.com'
})
}
})
})
// Notify has no reply, so only diagnostics reveal that the device failed to open the link.
expect(warned.mock.calls).toContainEqual([
'[web-shell] could not open a URL for the page',
{ url: 'mailto:someone@example.com', error: failure }
])
warned.mockRestore()
})
it('pops its own stack when the page hands its back button over', async () => {
dependencies.client = createFakeRpcClient()
const tree = await renderScreen(readyState('session-one'))
await act(async () => {
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'notify', name: BRIDGE_NAVIGATE_BACK_NOTIFY }) }
})
})
expect(dependencies.back).toHaveBeenCalledTimes(1)
expect(dependencies.push).not.toHaveBeenCalled()
})
// This file pins iOS swipe interception; use-shell-page-back.test.tsx covers platform key selection.
it('carries the page taking the device Back key up to the session', async () => {
dependencies.client = createFakeRpcClient()
const tree = await renderScreen(readyState('session-one'))
await act(async () => {
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: {
json: clientFrame({ type: 'notify', name: BRIDGE_BACK_CLAIM_NOTIFY, claimed: true })
}
})
})
expect(dependencies.reportPageBackClaim).toHaveBeenCalledWith(true)
})
it('pops nothing when this page is the first screen on the stack, rather than dismissing it', async () => {
dependencies.client = createFakeRpcClient()
dependencies.canGoBack = false
const warned = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
const tree = await renderScreen(readyState('session-one'))
await act(async () => {
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
byName(tree, 'ShellViewProbe')[0].props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'notify', name: BRIDGE_NAVIGATE_BACK_NOTIFY }) }
})
})
expect(dependencies.back).not.toHaveBeenCalled()
// Back notify has no reply; its log is the only evidence of failure.
expect(warned.mock.calls).toContainEqual([
'[web-shell-bridge] did not pop the stack for a page going back',
{ why: 'nothing-to-pop' }
])
warned.mockRestore()
})
it('shows a build id prefix and never the whole one, the cache path, or the host id', async () => {
const tree = await renderScreen(readyState('session-one'))
const text = textOf(tree)
expect(text).toContain(BUILD_ID.slice(0, 12))
expect(text).toContain('4096 B')
expect(text).toContain('811 ms')
expect(text).not.toContain(BUILD_ID)
expect(text).not.toContain(DIRECTORY)
expect(text).not.toContain('host-1')
})
})
describe('the dropped-frame count on the dev facts line', () => {
// 500,000 raw bytes exceed the frame cap once encoded.
const oversized = {
opcode: 1 as const,
seq: 1,
format: 'jpeg' as const,
metadata: {},
image: new Uint8Array(500_000)
}
async function openBinaryStream(tree: ReactTestRenderer): Promise<void> {
await act(async () => {
byName(tree, 'ShellViewProbe')[0]?.props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
})
await act(async () => {
byName(tree, 'ShellViewProbe')[0]?.props.onBridgeMessage({
nativeEvent: {
json: clientFrame({
type: 'subscribe',
id: 'a'.repeat(22),
method: 'browser.screencast',
params: {},
wantsBinary: true
})
}
})
})
}
async function drop(times: number): Promise<void> {
const emit = dependencies.client?.streams[0]?.emitBinary
if (emit === undefined || emit === null) {
throw new Error('binary subscription was never opened')
}
for (let index = 0; index < times; index += 1) {
await act(async () => {
emit({ ...oversized, seq: index + 1 })
})
}
}
function devFactsText(tree: ReactTestRenderer): string | null {
const line = byName(tree, 'Text').find(
(node) => node.props.testID === 'mobile-web-shell-dev-facts'
)
return line === undefined ? null : String(line.props.children)
}
it('shows the running total and resets it when the host is rebuilt', async () => {
dependencies.client = createFakeRpcClient()
dependencies.routeGrants = ['navigate', 'screencastBinary']
const tree = await renderScreen(readyState('session-one'))
await openBinaryStream(tree)
await drop(2)
expect(devFactsText(tree)).toContain('2 frames dropped')
await updateScreen(tree, readyState('session-two'))
expect(devFactsText(tree)).not.toContain('dropped')
})
// Dev facts render null in release; their updates must not rerender the screen at screencast frequency.
it('renders the screen not once more per dropped frame in a production build', async () => {
Object.assign(globalThis, { __DEV__: false })
try {
dependencies.client = createFakeRpcClient()
dependencies.routeGrants = ['navigate', 'screencastBinary']
const tree = await renderScreen(readyState('session-one'))
await openBinaryStream(tree)
expect(devFactsText(tree)).toBeNull()
const before = dependencies.viewRenders
await drop(5)
expect({ extraRenders: dependencies.viewRenders - before }).toEqual({ extraRenders: 0 })
expect(devFactsText(tree)).toBeNull()
} finally {
Object.assign(globalThis, { __DEV__: true })
}
})
})
// Keep update refusal separate from the working fallback document; dismissing its notice must not reload that document.
describe('a refused update is said beside the page, not in front of it', () => {
function dismissControl(tree: ReactTestRenderer): ReactTestInstance | undefined {
@@ -487,42 +69,4 @@ describe('a refused update is said beside the page, not in front of it', () => {
expect(byName(tree, 'ShellViewProbe')).toHaveLength(1)
expect(dependencies.lifecycle).toEqual([])
})
it('shows a later refusal rather than staying dismissed for the rest of the host', async () => {
dependencies.updateNotice = 'update-failed'
const tree = await renderScreen(readyState('session-one'))
await act(async () => {
tree.root
.find(
(node) =>
String(node.type) === 'Pressable' && node.props.accessibilityLabel === 'Dismiss notice'
)
.props.onPress()
})
// A new document’s refusal must not inherit the previous document’s dismissal.
await updateScreen(tree, readyState('session-two'))
expect(dismissControl(tree)).toBeDefined()
})
})
// Keep a cover until first paint; uncovering at ready exposed bare surface during measured 1.42-second cached-page startup.
describe('the frame under a page that has not painted', () => {
it('hands the page report to the session', async () => {
dependencies.pageFrame = 'unpainted'
dependencies.client = createFakeRpcClient()
const tree = await renderScreen(readyState('session-a'))
const probe = byName(tree, 'ShellViewProbe')[0]
await act(async () => {
probe.props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
})
expect(dependencies.reportPageReady).toHaveBeenCalledTimes(1)
await act(async () => {
probe.props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'notify', name: BRIDGE_PAGE_PAINTED }) }
})
})
expect(dependencies.reportPagePainted).toHaveBeenCalledTimes(1)
})
})
@@ -74,15 +74,4 @@ describe('the connection verdict hold', () => {
'stats.summary'
])
})
it('fails what waited when the host goes away before the verdict', async () => {
const { bridge } = heldBridge()
bridge.host.receive(
clientFrame({ type: 'request', id: bridgeId(1), method: 'worktree.ps', params: {} })
)
bridge.host.dispose()
await flushBridge()
expect(bridge.client.requests).toEqual([])
expect(bridge.last()).toMatchObject({ type: 'error', id: bridgeId(1) })
})
})
@@ -1,11 +1,5 @@
import { describe, expect, it } from 'vitest'
import {
BRIDGE_MAX_MESSAGE_BYTES,
BRIDGE_MAX_PENDING_REQUESTS,
BRIDGE_MAX_REPLY_BYTES,
BRIDGE_MAX_REPLY_PARTS,
utf8ByteLength
} from './bridge-caps'
import { BRIDGE_MAX_MESSAGE_BYTES, BRIDGE_MAX_REPLY_BYTES } from './bridge-caps'
import {
BRIDGE_PROTOCOL_VERSION,
readBridgeHostMessage,
@@ -20,7 +14,6 @@ import {
const ID = 'AAAAAAAAAAAAAAAAAAAAAA'
const OTHER_ID = 'BBBBBBBBBBBBBBBBBBBBBB'
const WORST_ESCAPING_CHARACTER = String.fromCharCode(1)
function payloadOf(result: unknown): BridgeReplyPayload {
return { id: 'r1', ok: true, result, _meta: { runtimeId: 'runtime-a' } }
@@ -97,7 +90,6 @@ function splitInsidePair(extra = ''): BridgeReplyMessage[] {
}
const ASTRAL = String.fromCodePoint(0x1f600)
const LONE_HIGH_SURROGATE = String.fromCharCode(0xd800)
function ceilingPayload(): BridgeReplyPayload {
const overhead = JSON.stringify(payloadOf('')).length
@@ -116,50 +108,6 @@ function assemble(frames: BridgeReplyMessage[]): ReturnType<BridgeReplyAssembler
}
describe('splitBridgeReply', () => {
it('leaves a reply that fits in one frame unchunked, its escaped payload spliced byte for byte', () => {
const payload = payloadOf(
`quote " slash \\ line\n\u0001 caf\u00e9 ${ASTRAL}${LONE_HIGH_SURROGATE}`
)
expect(rawFramesOf(splitBridgeReply(ID, payload))).toEqual([
'{"v":1,"type":"reply","id":"AAAAAAAAAAAAAAAAAAAAAA","payload":{"id":"r1","ok":true,"result":"quote \\" slash \\\\ line\\n\\u0001 café \u{1f600}\\ud800","_meta":{"runtimeId":"runtime-a"}}}'
])
})
it('chunks a reply over the frame cap', () => {
const frames = framesOf(splitBridgeReply(ID, payloadOf('x'.repeat(1_500_000))))
expect(frames.length).toBeGreaterThan(2)
expect(frames.map((frame) => ('part' in frame ? frame.part.i : -1))).toEqual(
frames.map((_, index) => index)
)
})
it('ships only frames the receiving side will accept', () => {
for (const raw of rawFramesOf(splitBridgeReply(ID, payloadOf('x'.repeat(1_500_000))))) {
expect(utf8ByteLength(raw)).toBeLessThanOrEqual(BRIDGE_MAX_MESSAGE_BYTES)
expect(readBridgeHostMessage(raw).ok).toBe(true)
}
})
it('splits the worst reply the ceiling admits into fewer parts than the schema allows', () => {
// Use maximum-size fully re-escaped content to prove every accepted reply stays below the part-count ceiling.
const empty = payloadOf('')
const backslashes = Math.floor((BRIDGE_MAX_REPLY_BYTES - JSON.stringify(empty).length) / 2)
const payload = payloadOf('\\'.repeat(backslashes))
expect(new TextEncoder().encode(JSON.stringify(payload)).byteLength).toBeLessThanOrEqual(
BRIDGE_MAX_REPLY_BYTES
)
expect(new TextEncoder().encode(JSON.stringify(payload)).byteLength).toBeGreaterThan(
BRIDGE_MAX_REPLY_BYTES - 4
)
const split = splitBridgeReply(ID, payload)
const frames = framesOf(split)
expect(BRIDGE_MAX_REPLY_PARTS).toBeGreaterThan(frames.length)
for (const raw of rawFramesOf(split)) {
expect(utf8ByteLength(raw)).toBeLessThanOrEqual(BRIDGE_MAX_MESSAGE_BYTES)
}
expect(assemble(frames)).toEqual({ status: 'complete', payload })
})
it('never cuts a frame inside a surrogate pair, at any cut parity', () => {
for (let padding = 0; padding < 4; padding += 1) {
const payload = payloadOf(`${'x'.repeat(padding)}${ASTRAL.repeat(1_000_000)}`)
@@ -178,80 +126,9 @@ describe('splitBridgeReply', () => {
}
}
})
it('round-trips a reply of exactly the ceiling, cuts and all', () => {
const payload = ceilingPayload()
expect(new TextEncoder().encode(JSON.stringify(payload)).byteLength).toBe(
BRIDGE_MAX_REPLY_BYTES
)
expect(assemble(framesOf(splitBridgeReply(ID, payload)))).toEqual({
status: 'complete',
payload
})
})
it('refuses a lone-surrogate reply over the ceiling rather than splitting it', () => {
const payload = payloadOf(LONE_HIGH_SURROGATE.repeat(BRIDGE_MAX_REPLY_BYTES / 6))
expect(splitBridgeReply(ID, payload)).toEqual({ ok: false, refusal: 'reply-too-large' })
})
it('round-trips lone surrogates that fit', () => {
const payload = payloadOf(LONE_HIGH_SURROGATE.repeat(200_000))
expect(assemble(framesOf(splitBridgeReply(ID, payload)))).toEqual({
status: 'complete',
payload
})
})
it('refuses a reply over the ceiling instead of chunking it forever', () => {
const oversized = payloadOf('x'.repeat(BRIDGE_MAX_REPLY_BYTES + 1))
expect(splitBridgeReply(ID, oversized)).toEqual({ ok: false, refusal: 'reply-too-large' })
})
})
describe('round trip', () => {
const payloads: [string, BridgeReplyPayload][] = [
['a small reply', payloadOf({ ok: 1 })],
['a reply spanning several frames', payloadOf('x'.repeat(1_500_000))],
['a reply of astral characters', payloadOf('\u{1f600}'.repeat(400_000))],
['a reply of control characters', payloadOf(WORST_ESCAPING_CHARACTER.repeat(1_300_000))],
['a reply of mixed widths', payloadOf(`${'é'.repeat(300_000)}${'中'.repeat(300_000)}`)]
]
for (const [name, payload] of payloads) {
it(`reassembles ${name} byte for byte`, () => {
const split = splitBridgeReply(ID, payload)
const frames = framesOf(split)
expect(frames.length).toBeLessThanOrEqual(BRIDGE_MAX_REPLY_PARTS)
for (const raw of rawFramesOf(split)) {
expect(new TextEncoder().encode(raw).byteLength).toBeLessThanOrEqual(
BRIDGE_MAX_MESSAGE_BYTES
)
}
expect(assemble(frames)).toEqual({
status: 'complete',
payload
})
})
}
it('restores a surrogate pair that was cut in half between two frames', () => {
// JSON escapes lone surrogate halves; joining the decoded parts must restore the original pair.
const head = '{"id":"r1","ok":true,"result":"\ud83d'
const tail = '\ude00","_meta":{"runtimeId":"runtime-a"}}'
expect(JSON.parse(JSON.stringify(head))).toBe(head)
expect(assemble([part(0, 2, head), part(1, 2, tail)])).toEqual({
status: 'complete',
payload: payloadOf('\u{1f600}')
})
})
it('reassembles frames that arrive out of order', () => {
const payload = payloadOf('x'.repeat(1_500_000))
const frames = framesOf(splitBridgeReply(ID, payload))
expect(assemble(frames.toReversed())).toEqual({ status: 'complete', payload })
})
it('keeps two replies apart while both are in flight', () => {
const first = payloadOf('x'.repeat(1_500_000))
const second = payloadOf('y'.repeat(1_500_000))
@@ -273,21 +150,6 @@ describe('round trip', () => {
})
describe('BridgeReplyAssembler refusals', () => {
it('stays pending while a part is missing', () => {
const assembler = new BridgeReplyAssembler()
expect(assembler.accept(part(0, 3, '{"id"'))).toEqual({ status: 'pending' })
expect(assembler.accept(part(2, 3, '}'))).toEqual({ status: 'pending' })
})
it('refuses a part index that arrived already, and drops what it held', () => {
const assembler = new BridgeReplyAssembler()
expect(assembler.accept(part(0, 2, 'a'))).toEqual({ status: 'pending' })
expect(assembler.accept(part(0, 2, 'a'))).toEqual({
status: 'failed',
refusal: 'duplicate-part'
})
})
it('keeps a refused id refused, so a sender cannot start over on the next part', () => {
const assembler = new BridgeReplyAssembler()
assembler.accept(part(0, 3, '{"id"'))
@@ -317,56 +179,6 @@ describe('BridgeReplyAssembler refusals', () => {
expect(assembler.accept(part(0, 3, '{"id"'))).toEqual({ status: 'pending' })
})
it('refuses every later part of a reply that went past the ceiling', () => {
const assembler = new BridgeReplyAssembler()
const frames = asciiParts(BRIDGE_MAX_REPLY_BYTES + 1)
for (const frame of frames.slice(0, -1)) {
expect(assembler.accept(frame)).toEqual({ status: 'pending' })
}
expect(assembler.accept(requiredLast(frames))).toEqual({
status: 'failed',
refusal: 'reply-too-large'
})
for (const frame of checkedParts(['new', 'reply'])) {
expect(assembler.accept(frame)).toEqual({ status: 'failed', refusal: 'reply-too-large' })
}
})
it('refuses a part whose count disagrees with the parts already held', () => {
const assembler = new BridgeReplyAssembler()
expect(assembler.accept(part(0, 2, 'a'))).toEqual({ status: 'pending' })
expect(assembler.accept(part(1, 3, 'b'))).toEqual({
status: 'failed',
refusal: 'inconsistent-part'
})
})
it('refuses a part index that is not inside its own count', () => {
expect(new BridgeReplyAssembler().accept(part(2, 2, 'a'))).toEqual({
status: 'failed',
refusal: 'inconsistent-part'
})
})
it('holds no more half-assembled replies than there can be requests in flight', () => {
const assembler = new BridgeReplyAssembler()
const idOf = (index: number): string => `id${String(index).padStart(20, '0')}`
for (let index = 0; index < BRIDGE_MAX_PENDING_REQUESTS; index += 1) {
expect(assembler.accept(part(0, 2, 'a', idOf(index)))).toEqual({ status: 'pending' })
}
const overflowing = idOf(BRIDGE_MAX_PENDING_REQUESTS)
expect(assembler.accept(part(0, 2, 'a', overflowing))).toEqual({
status: 'failed',
refusal: 'too-many-pending'
})
expect(assembler.accept(part(1, 2, 'b', idOf(0)))).toEqual({
status: 'failed',
refusal: 'malformed-json'
})
assembler.discard(overflowing)
expect(assembler.accept(part(0, 2, 'a', overflowing))).toEqual({ status: 'pending' })
})
it('refuses the part that would push every reply in flight past the aggregate', () => {
const assembler = new BridgeReplyAssembler()
const idOf = (index: number) => `id${String(index).padStart(20, '0')}`
@@ -388,29 +200,6 @@ describe('BridgeReplyAssembler refusals', () => {
})
})
it('forgets every refusal when it is cleared for teardown', () => {
const assembler = new BridgeReplyAssembler()
assembler.accept(part(0, 2, 'a'))
expect(assembler.accept(part(0, 2, 'a'))).toEqual({
status: 'failed',
refusal: 'duplicate-part'
})
assembler.clear()
expect(assembler.accept(part(0, 2, 'a'))).toEqual({ status: 'pending' })
})
it('frees a slot when the page discards an id it abandoned', () => {
const assembler = new BridgeReplyAssembler()
const idOf = (index: number): string => `id${String(index).padStart(20, '0')}`
for (let index = 0; index < BRIDGE_MAX_PENDING_REQUESTS; index += 1) {
assembler.accept(part(0, 2, 'a', idOf(index)))
}
assembler.discard(idOf(3))
expect(assembler.accept(part(0, 2, 'a', idOf(BRIDGE_MAX_PENDING_REQUESTS)))).toEqual({
status: 'pending'
})
})
it('measures joined UTF8 bytes when a surrogate pair crosses parts', () => {
const payload = ceilingPayload()
expect(new TextEncoder().encode(JSON.stringify(payload)).byteLength).toBe(
@@ -426,67 +215,4 @@ describe('BridgeReplyAssembler refusals', () => {
expect(new TextEncoder().encode(joined).byteLength).toBeGreaterThan(BRIDGE_MAX_REPLY_BYTES)
expect(assemble(frames)).toEqual({ status: 'failed', refusal: 'reply-too-large' })
})
it('retains incomplete ASCII parts totaling exactly the reply ceiling', () => {
const assembler = new BridgeReplyAssembler()
for (const frame of asciiParts(BRIDGE_MAX_REPLY_BYTES)) {
expect(assembler.accept(frame)).toEqual({ status: 'pending' })
}
})
it('aborts incomplete ASCII parts one byte past the reply ceiling', () => {
const assembler = new BridgeReplyAssembler()
const frames = asciiParts(BRIDGE_MAX_REPLY_BYTES + 1)
for (const frame of frames.slice(0, -1)) {
expect(assembler.accept(frame)).toEqual({ status: 'pending' })
}
expect(assembler.accept(requiredLast(frames))).toEqual({
status: 'failed',
refusal: 'reply-too-large'
})
})
it('refuses parts that do not reassemble into JSON', () => {
const assembler = new BridgeReplyAssembler()
assembler.accept(part(0, 2, '{"id":'))
expect(assembler.accept(part(1, 2, 'not json'))).toEqual({
status: 'failed',
refusal: 'malformed-json'
})
})
it('refuses parts that reassemble into something that is not a reply', () => {
const assembler = new BridgeReplyAssembler()
assembler.accept(part(0, 2, '{"id":"r1",'))
expect(assembler.accept(part(1, 2, '"ok":true}'))).toEqual({
status: 'failed',
refusal: 'unrecognised-message'
})
})
it('drops a half-assembled reply when the whole one arrives instead', () => {
const assembler = new BridgeReplyAssembler()
const payload = payloadOf({ ok: 1 })
assembler.accept(part(0, 2, '{"id":'))
expect(
assembler.accept({ v: BRIDGE_PROTOCOL_VERSION, type: 'reply', id: ID, payload })
).toEqual({ status: 'complete', payload })
expect(assembler.accept(part(0, 2, '{"id":'))).toEqual({ status: 'pending' })
})
it('forgets a reply the page abandoned', () => {
const assembler = new BridgeReplyAssembler()
assembler.accept(part(0, 2, 'a'))
assembler.discard(ID)
expect(assembler.accept(part(0, 2, 'a'))).toEqual({ status: 'pending' })
})
it('forgets every reply on teardown', () => {
const assembler = new BridgeReplyAssembler()
assembler.accept(part(0, 2, 'a'))
assembler.accept(part(0, 2, 'a', OTHER_ID))
assembler.clear()
expect(assembler.accept(part(0, 2, 'a'))).toEqual({ status: 'pending' })
expect(assembler.accept(part(0, 2, 'a', OTHER_ID))).toEqual({ status: 'pending' })
})
})
@@ -1,53 +0,0 @@
import { afterEach, describe, expect, it } from 'vitest'
import { MOBILE_WEB_SHELL_GRANTS } from '../page-route-policy'
import { createFakeBridgePortPair, disposeBridgePortPair } from './bridge-port-pair-test-harness'
import { createPageDeviceStore } from './page-device-store'
import { storeParamsSchema } from './bridge-store-verb'
let pair: ReturnType<typeof createFakeBridgePortPair> | null = null
afterEach(async () => {
if (pair) {
await disposeBridgePortPair(pair)
}
pair = null
})
describe('the page device store', () => {
it('answers unavailable without asking a shell that did not grant the verb', async () => {
pair = createFakeBridgePortPair({
routeGrants: MOBILE_WEB_SHELL_GRANTS.filter((grant) => grant !== 'native.store.rows')
})
await pair.flush()
const store = createPageDeviceStore(pair.client)
expect(await store.read('cache', ['q-1'])).toEqual({ status: 'unavailable' })
expect(await store.write('draft', [{ key: 'draft:chat::t', value: 'dHlwZWQ=' }])).toEqual({
written: false,
refusal: 'unavailable'
})
expect(pair.toShell.filter((json) => json.includes('"native.store.rows"'))).toEqual([])
})
it('reads deferred keys again until every value is in hand', async () => {
const stored: Record<string, string> = { a: 'QQ==', b: 'Qg==', c: 'Qw==' }
pair = createFakeBridgePortPair({
// Fills only the first key of each read, like a reply that hit its budget.
serveNativeVerb: async (_verb, params) => {
const call = storeParamsSchema.parse(params)
const keys = call.action === 'read' ? call.keys : []
return {
values: keys.map((key, at) => (at === 0 ? stored[key] : null)),
deferred: keys.slice(1).map((_key, at) => at + 1)
}
}
})
await pair.flush()
const store = createPageDeviceStore(pair.client)
expect(await store.read('cache', ['a', 'b', 'c'])).toEqual({
status: 'ok',
values: ['QQ==', 'Qg==', 'Qw==']
})
})
})
@@ -1,121 +0,0 @@
// Push host B over A, then pop: A must regain area ownership without a duplicate native sidebar.
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const harness = await vi.hoisted(async () => await import('./mobile-web-shell-screen-test-harness'))
const dependencies = vi.hoisted(() => harness.createScreenDependencies())
const { screenModuleMocks } = await vi.hoisted(
async () => await import('./mobile-web-shell-screen-test-mocks')
)
const mocks = vi.hoisted(() => screenModuleMocks(dependencies))
const stack = await vi.hoisted(async () => {
const React = await import('react')
const hosts: string[] = ['host-a']
return {
hosts,
Focused: React.createContext(true),
HostSidebar: function HostSidebar(): null {
return null
}
}
})
vi.mock('react-native', () => ({
...mocks['react-native'](),
PanResponder: { create: () => ({ panHandlers: {} }) },
useWindowDimensions: () => ({ width: 1180, height: 820 })
}))
vi.mock('expo-router', async () => {
const React = await import('react')
return {
...mocks['expo-router'](),
useGlobalSearchParams: () => ({ hostId: stack.hosts.at(-1) }),
// Model native stack focus: rerun only for the top screen when it returns.
useFocusEffect: (effect: () => undefined | (() => void)) => {
const focused = React.useContext(stack.Focused)
React.useEffect(() => (focused ? effect() : undefined), [focused, effect])
}
}
})
vi.mock('expo-clipboard', mocks['expo-clipboard'])
vi.mock('expo-haptics', mocks['expo-haptics'])
vi.mock('expo-document-picker', mocks['expo-document-picker'])
vi.mock('@orca/expo-two-way-audio', mocks['@orca/expo-two-way-audio'])
vi.mock('expo-keep-awake', mocks['expo-keep-awake'])
vi.mock('expo-image-picker', mocks['expo-image-picker'])
vi.mock('expo-file-system', mocks['expo-file-system'])
vi.mock('../device-store/device-store', mocks['../device-store/device-store'])
vi.mock('lucide-react-native', mocks['lucide-react-native'])
vi.mock('react-native-safe-area-context', mocks['react-native-safe-area-context'])
vi.mock('../../modules/orca-mobile-web-shell/src', mocks['../../modules/orca-mobile-web-shell/src'])
vi.mock('../app-update/use-wall-app-update', mocks['../app-update/use-wall-app-update'])
vi.mock('../transport/host-client-hooks', mocks['../transport/host-client-hooks'])
vi.mock('./use-page-host-snapshot', mocks['./use-page-host-snapshot'])
vi.mock('./use-mobile-web-shell-session', () => ({
useMobileWebShellSession: (args: { routePathname: string }) => ({
...mocks['./use-mobile-web-shell-session']().useMobileWebShellSession(),
ownsHostArea: /^\/h\/[^/]+$/.test(args.routePathname)
})
}))
vi.mock('../theme/mobile-theme', async (original) => ({
...(await original<Record<string, unknown>>()),
colors: {}
}))
vi.mock('../storage/preferences', () => ({
HOST_SIDEBAR_DEFAULT_WIDTH: 320,
HOST_SIDEBAR_MAX_WIDTH: 480,
HOST_SIDEBAR_MIN_WIDTH: 240,
loadHostSidebarWidth: async () => 320,
saveHostSidebarWidth: async () => {}
}))
vi.mock('../components/HostProtocolGate', () => ({
HostProtocolGate: ({ children }: { children: unknown }) => children
}))
vi.mock('../host-screen/HostScreen', () => ({ HostScreen: stack.HostSidebar }))
vi.mock('../navigation/host-stack', async () => {
const { MobileWebShellScreen } = await import('./MobileWebShellScreen')
return {
HostStack: () =>
stack.hosts.map((hostId, index) => (
<stack.Focused.Provider key={hostId} value={index === stack.hosts.length - 1}>
<MobileWebShellScreen hostId={hostId} route={{ pathname: `/h/${hostId}` }} />
</stack.Focused.Provider>
))
}
})
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import HostGroupLayout from '../../app/h/_layout'
const mounted: { tree: ReactTestRenderer | null } = { tree: null }
async function show(hosts: string[]): Promise<number> {
stack.hosts = hosts
dependencies.pathname = `/h/${hosts.at(-1) ?? ''}`
await act(async () => {
if (mounted.tree === null) {
mounted.tree = create(<HostGroupLayout />)
} else {
mounted.tree.update(<HostGroupLayout />)
}
})
await act(async () => {})
return mounted.tree?.root.findAllByType(stack.HostSidebar).length ?? 0
}
beforeEach(() => {
harness.resetScreenDependencies(dependencies)
dependencies.state = harness.readyState('session-1')
mounted.tree = null
})
afterEach(() => {
act(() => mounted.tree?.unmount())
})
describe('two hosts whose pages own the host area', () => {
it('draws no native sidebar beside either, through a push and the pop back', async () => {
expect(await show(['host-a'])).toBe(0)
expect(await show(['host-a', 'host-b'])).toBe(0)
expect(await show(['host-a'])).toBe(0)
})
})
@@ -13,36 +13,12 @@ describe('the page claiming the device Back key', () => {
)
}
it('records the claim and gives it back when the page lets go', () => {
const held = claimed()
expect(shellPageBackClaimed(held.session)).toBe(true)
expect(
shellPageBackClaimed(run(held.session, { type: 'page-back-claim', claimed: false }).session)
).toBe(false)
})
it('drops it when a replacement document starts inside this mount', () => {
expect(shellPageBackClaimed(run(claimed().session, { type: 'document-started' }).session)).toBe(
false
)
})
it('drops it when the view is remounted under a new session id', () => {
const remounted = run(claimed().session, { type: 'remounted', sessionId: 'session-two' })
expect(shellPageBackClaimed(remounted.session)).toBe(false)
})
it('drops it when the document asks for a session again, so the page has to claim again', () => {
const reasked = run(claimed().session, { type: 'page-ready' })
expect(shellPageBackClaimed(reasked.session)).toBe(false)
})
it('drops it when a refetch takes the generation off screen', () => {
const failed = run(claimed().session, { type: 'shell-failed', reason: 'generation-unreadable' })
expect(failed.session.state.kind).not.toBe('ready')
expect(shellPageBackClaimed(failed.session)).toBe(false)
})
it('records nothing from a page whose generation is no longer on screen', () => {
const failed = run(claimed().session, { type: 'shell-failed', reason: 'isolation-unavailable' })
const late = run(failed.session, { type: 'page-back-claim', claimed: true })
@@ -1,96 +0,0 @@
import { describe, expect, it } from 'vitest'
import {
MANIFEST,
awaitingManifest,
createMobileWebShellSession,
gates,
run
} from './mobile-web-shell-session-test-fixtures'
const UNLISTED_WALL = { kind: 'wall', verdict: { kind: 'blocked', reason: 'page-route-unlisted' } }
describe('a manifest whose page does not serve this route walls instead of going native', () => {
it('walls the desktop as too old for a route the bundle does not list', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: { ...MANIFEST, routes: [{ pathname: '/h/[hostId]/tasks', grants: [] }] }
})
expect(step.session.state).toEqual(UNLISTED_WALL)
expect(step.effects).toEqual([])
})
it('walls this app as too old for a route listed with a grant it does not implement', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: {
...MANIFEST,
routes: [{ pathname: '/h/[hostId]', grants: ['navigate', 'teleport'] }]
}
})
expect(step.session.state).toEqual({
kind: 'wall',
verdict: { kind: 'blocked', reason: 'page-route-grant-missing' }
})
expect(step.effects).toEqual([])
})
it('walls the desktop as too old when it predates the routes field itself', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: { ...MANIFEST, routes: undefined }
})
expect(step.session.state).toEqual(UNLISTED_WALL)
})
it('answers the compat wall before the route, since an unreadable schema hides the route list', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: { ...MANIFEST, schemaVersion: 99, routes: [] }
})
expect(step.session.state).toEqual({
kind: 'wall',
verdict: { kind: 'blocked', reason: 'bundle-shell-too-old', schemaVersion: 99 }
})
})
it('walls a page below the floor as it is, whatever routes it lists', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: { ...MANIFEST, pageVersion: 0, routes: [] }
})
expect(step.session.state).toMatchObject({
kind: 'wall',
verdict: { reason: 'bundle-incompatible', side: 'desktop', pageVersion: 0 }
})
})
it('says the screen is unavailable, not the desktop too old, for a pathname this app has no screen for', () => {
const opened = run(
createMobileWebShellSession('/h/host-1/insights', false, false),
{ type: 'gates-changed', gates: gates() },
{ type: 'cache-read', generation: null }
)
const step = run(opened.session, { type: 'manifest-read', manifest: MANIFEST })
expect(step.session.state).toEqual({ kind: 'route-unavailable' })
})
it('says the screen is unavailable when the manifest carries a pattern this shell cannot read', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: { ...MANIFEST, routes: [{ pathname: '/h/[...a]/[...b]', grants: [] }] }
})
expect(step.session.state).toEqual({ kind: 'route-unavailable' })
})
it('keeps that answer across a layout flip, which rebuilds the session', () => {
const opened = run(
createMobileWebShellSession('/h/host-1/insights', false, false),
{ type: 'gates-changed', gates: gates() },
{ type: 'cache-read', generation: null },
{ type: 'manifest-read', manifest: MANIFEST }
)
expect(run(opened.session, { type: 'layout-changed', wide: true }).session.appNamesRoute).toBe(
false
)
})
})
@@ -11,8 +11,6 @@ import {
withoutRecord
} from './mobile-web-shell-session-test-fixtures'
const DOWNLOAD_FAILED = { kind: 'failed', reason: 'download-failed', retriedOnce: false }
// Refused updates should fall back to intact cached bytes under their own routes/grants, as offline entry does, while respecting any reachable host’s compatibility window.
describe('an update this shell refused falls back to the generation that already works', () => {
// Change assets and grants so the new manifest cannot safely authorize the old bytes.
@@ -30,66 +28,10 @@ describe('an update this shell refused falls back to the generation that already
)
}
it('asks for the newer generation before any of this, so the refusal is a real one', () => {
const fetching = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: NEWER
})
expect(fetching.session.state).toMatchObject({ kind: 'fetching' })
expect(fetching.effects).toEqual([{ kind: 'download' }])
})
it('opens the cached generation rather than walling a host it can still reach', () => {
const step = refused()
expect(step.session.updateNotice).toBe('update-failed')
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(withoutRecord(step.effects)).toEqual([
{
kind: 'open-generation',
directory: CACHED.directory,
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes
}
])
})
it('runs it under its own grants, not the ones the refused manifest declared', () => {
expect(refused().session.routeGrants).toEqual(['navigate'])
})
it('names the refusal as a notice beside the workspace, not as a state in front of it', () => {
const ready = run(refused().session, {
type: 'activated',
generationDirectory: CACHED.directory,
sessionId: 'session-one',
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes,
elapsedMs: 8
})
expect(ready.session.state).toMatchObject({ kind: 'ready', buildId: CACHED.buildId })
expect(ready.session.updateNotice).toBe('update-failed')
})
it('leaves the refused generation out of the cache and keeps the cached one', () => {
const step = refused()
expect(step.session.cached).toEqual(CACHED)
expect(step.effects.map((effect) => effect.kind)).not.toContain('delete-cache')
})
it('still walls when there is no cached generation to fall back to', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: NEWER
})
const failed = run(step.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
expect(failed.session.state).toEqual({
kind: 'failed',
reason: 'download-failed',
retriedOnce: false
})
expect(withoutRecord(failed.effects)).toEqual([])
})
it('walls the cached generation the host has moved past rather than serving it', () => {
// Unlike offline fallback, this reachable host can have moved outside the cached bundle’s compatibility window.
const step = run(
@@ -111,28 +53,6 @@ describe('an update this shell refused falls back to the generation that already
})
expect(withoutRecord(step.effects)).toEqual([])
})
it('shows the download failure when the cached bundle never carried the route, before any wall', () => {
// An unclaimed cached route is download failure, not a compat wall, even when those unused bytes are below the host floor.
const fetching = run(awaitingManifest({ ...CACHED_BELOW_HOST_FLOOR, routes: [] }).session, {
type: 'manifest-read',
manifest: NEWER
})
const step = run(fetching.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
expect(step.session.state).toEqual(DOWNLOAD_FAILED)
expect(step.session.updateNotice).toBeNull()
expect(withoutRecord(step.effects)).toEqual([])
})
it('shows the download failure for a generation from before routes were listed at all', () => {
// Older cached manifests lack routes and cannot claim this one; do not wall bytes that will not run.
const fetching = run(
awaitingManifest({ ...CACHED_BELOW_HOST_FLOOR, routes: undefined }).session,
{ type: 'manifest-read', manifest: NEWER }
)
const step = run(fetching.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
expect(step.session.state).toEqual(DOWNLOAD_FAILED)
})
})
// Gates can change during fetching; fallback must use their current verdict, including recoverable unreadable status, instead of inventing another decision.
@@ -148,16 +68,6 @@ describe('the fallback answers each gate verdict the way the rest of the shell d
return run(moved.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
}
it('walls the host when it has stopped serving a bundle at all', () => {
const step = refusedUnder({ hostCapabilities: [] })
expect(step.session.state).toEqual({
kind: 'wall',
verdict: { kind: 'blocked', reason: 'bundle-unavailable' }
})
expect(step.session.updateNotice).toBeNull()
expect(withoutRecord(step.effects)).toEqual([])
})
it('says the status could not be read rather than serving a generation it cannot judge', () => {
const step = refusedUnder({ statusReadable: false, hostCapabilities: [] })
expect(step.session.state).toEqual({
@@ -169,68 +79,4 @@ describe('the fallback answers each gate verdict the way the rest of the shell d
{ kind: 'open-cache' }
])
})
it('serves a generation the host can no longer be asked about, compat check and all skipped', () => {
// Offline fallback skips compatibility checks because no reachable host has stated a newer window.
const step = refusedUnder({ reachability: 'unreachable' }, CACHED_BELOW_HOST_FLOOR)
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(step.session.updateNotice).toBe('update-failed')
})
it.each([{ reachability: 'connecting' as const }, { statusPending: true, hostCapabilities: [] }])(
'opens the cached generation before the verdict (%o), which then judges it',
(patch) => {
const step = refusedUnder(patch, CACHED_BELOW_HOST_FLOOR)
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
}
)
it('judges the generation only on the verdict that leaves a host to judge against', () => {
const step = refusedUnder({}, CACHED_BELOW_HOST_FLOOR)
expect(step.session.state).toMatchObject({ kind: 'wall' })
})
})
describe('an update this shell refused, once it is on screen', () => {
const NEWER = manifestFacts({ ...MANIFEST_WIRE, buildId: 'c'.repeat(64) })
function refused() {
return run(
awaitingManifest(CACHED).session,
{ type: 'manifest-read', manifest: NEWER },
{ type: 'download-failed', cause: BUNDLE_REFUSED }
)
}
it('tries the update again on the next run of the flow, and drops the notice with it', () => {
const retried = run(refused().session, { type: 'retry-pressed' })
expect(retried.session.updateNotice).toBeNull()
expect(retried.effects).toEqual([{ kind: 'open-cache' }])
const again = run(
retried.session,
{ type: 'cache-read', generation: CACHED },
{
type: 'activated',
generationDirectory: CACHED.directory,
sessionId: 'session-two',
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes,
elapsedMs: 8
}
)
expect(again.effects).toContainEqual({ kind: 'read-manifest' })
})
it('drops the notice the moment the flow runs again, before anything is known again', () => {
const served = run(refused().session, {
type: 'activated',
generationDirectory: CACHED.directory,
sessionId: 'session-one',
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes,
elapsedMs: 8
})
const dropped = run(served.session, { type: 'shell-failed', reason: 'generation-unreadable' })
expect(dropped.session.updateNotice).toBeNull()
})
})
@@ -1,91 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const harness = await vi.hoisted(async () => await import('./mobile-web-shell-screen-test-harness'))
const dependencies = vi.hoisted(() => harness.createScreenDependencies())
const { screenModuleMocks } = await vi.hoisted(
async () => await import('./mobile-web-shell-screen-test-mocks')
)
const mocks = vi.hoisted(() => screenModuleMocks(dependencies))
vi.mock('react-native', mocks['react-native'])
vi.mock('expo-clipboard', mocks['expo-clipboard'])
vi.mock('expo-haptics', mocks['expo-haptics'])
vi.mock('expo-document-picker', mocks['expo-document-picker'])
vi.mock('@orca/expo-two-way-audio', mocks['@orca/expo-two-way-audio'])
vi.mock('expo-keep-awake', mocks['expo-keep-awake'])
vi.mock('expo-image-picker', mocks['expo-image-picker'])
vi.mock('expo-file-system', mocks['expo-file-system'])
vi.mock('../device-store/device-store', mocks['../device-store/device-store'])
vi.mock('lucide-react-native', mocks['lucide-react-native'])
vi.mock('react-native-safe-area-context', mocks['react-native-safe-area-context'])
vi.mock('expo-router', mocks['expo-router'])
vi.mock('../../modules/orca-mobile-web-shell/src', mocks['../../modules/orca-mobile-web-shell/src'])
vi.mock('../app-update/use-wall-app-update', mocks['../app-update/use-wall-app-update'])
vi.mock('../transport/host-client-hooks', mocks['../transport/host-client-hooks'])
vi.mock('./use-page-host-snapshot', mocks['./use-page-host-snapshot'])
vi.mock('./use-mobile-web-shell-session', mocks['./use-mobile-web-shell-session'])
import { act } from 'react-test-renderer'
import { clientFrame, createFakeRpcClient } from './bridge-host-test-fakes'
import {
byName,
readyState,
renderScreen as mountScreen
} from './mobile-web-shell-screen-test-harness'
import { readBridgeHostMessage } from './bridge/bridge-envelope'
import { MobileWebShellScreen } from './MobileWebShellScreen'
import type { MobileWebShellSessionState } from './mobile-web-shell-session-contract'
import type { ReactTestRenderer } from 'react-test-renderer'
const renderScreen = (state: MobileWebShellSessionState): Promise<ReactTestRenderer> =>
mountScreen(MobileWebShellScreen, dependencies, state)
afterEach(harness.unmountRenderedScreens)
beforeEach(() => {
harness.resetScreenDependencies(dependencies)
})
// Give the page the whole window; its SafeAreaViews pad from init insets like native screens.
describe('a page that owns its safe area', () => {
async function openPage(sessionId: string) {
dependencies.client = createFakeRpcClient()
const tree = await renderScreen(readyState(sessionId))
await act(async () => {
byName(tree, 'ShellViewProbe')[0]?.props.onBridgeMessage({
nativeEvent: { json: clientFrame({ type: 'ready' }) }
})
})
const root = () => tree.root.find((node) => node.props.testID === 'mobile-web-shell-ready')
const initInsets = () =>
dependencies.posted.flatMap((json) => {
const read = readBridgeHostMessage(json)
return read.ok && read.message.type === 'init' ? [read.message.safeAreaInsets ?? null] : []
})
return { tree, root, initInsets }
}
const ownedPage = openPage
const WINDOW = { top: 44, right: 0, bottom: 8, left: 0 }
it('draws the view edge-to-edge and hands the page the insets it now sits under', async () => {
const page = await ownedPage('session-owned')
expect(page.root().props.style[1]).toEqual({ paddingTop: 0 })
expect(page.initInsets()).toEqual([WINDOW])
})
it('gives the status bar strip to the update banner while it shows', async () => {
dependencies.updateNotice = 'update-failed'
const page = await ownedPage('session-owned-banner')
expect(page.root().props.style[1]).toEqual({ paddingTop: 44 })
expect(page.initInsets()).toEqual([{ ...WINDOW, top: 0 }])
const dismiss = byName(page.tree, 'Pressable').find(
(node) => node.props.accessibilityLabel === 'Dismiss notice'
)
expect(dismiss).toBeDefined()
await act(async () => {
dismiss?.props.onPress()
})
expect(page.root().props.style[1]).toEqual({ paddingTop: 0 })
expect(page.initInsets()).toEqual([{ ...WINDOW, top: 0 }, WINDOW])
})
})
@@ -1,107 +0,0 @@
import { describe, expect, it } from 'vitest'
import type {
CachedGeneration,
MobileWebShellManifestFacts
} from './mobile-web-shell-session-contract'
import {
CACHED,
MANIFEST,
MANIFEST_WIRE,
PAGE_ROUTES,
awaitingManifest,
manifestFacts,
run,
LINK_LOST
} from './mobile-web-shell-session-test-fixtures'
// Fallback must restore cached routes/grants; the replacement manifest must not grant old bytes capabilities they never declared.
describe('falling back to the cached generation after a failed download', () => {
const cachedOnlyNavigate: CachedGeneration = { ...CACHED, routes: PAGE_ROUTES }
// Use a distinct build id to force download instead of the same-build cache path.
const manifestWithClipboard: MobileWebShellManifestFacts = manifestFacts({
...MANIFEST_WIRE,
buildId: 'd'.repeat(64),
routes: [{ pathname: '/h/[hostId]', grants: ['navigate', 'native.clipboard.read'] }]
})
it('opens it under its own grants, not the ones the newer manifest declared', () => {
const fetching = run(awaitingManifest(cachedOnlyNavigate).session, {
type: 'manifest-read',
manifest: manifestWithClipboard
})
expect([...fetching.session.routeGrants]).toEqual(['navigate', 'native.clipboard.read'])
const step = run(fetching.session, { type: 'download-failed', cause: LINK_LOST })
expect(step.session.state.kind).toBe('activating')
expect([...step.session.routeGrants]).toEqual(['navigate'])
})
it('carries a verb declared in the manifest through to the session grants', () => {
const step = run(awaitingManifest(null).session, {
type: 'manifest-read',
manifest: manifestFacts({
...MANIFEST_WIRE,
routes: [{ pathname: '/h/[hostId]', grants: ['navigate', 'native.clipboard.write'] }]
})
})
expect([...step.session.routeGrants]).toEqual(['navigate', 'native.clipboard.write'])
})
})
// Carry pageRouteGrants through downloads too; otherwise first installs/updates treat every target as unpaired and hand all hops to native.
describe('the route grants a downloaded generation is activated under', () => {
const TWO_ROUTES = [
{ pathname: '/h/[hostId]', grants: ['navigate', 'storage'] },
{ pathname: '/h/[hostId]/tasks', grants: ['navigate', 'native.clipboard.write'] }
]
const DOWNLOADED: MobileWebShellManifestFacts = manifestFacts({
...MANIFEST_WIRE,
buildId: 'c'.repeat(64),
routes: TWO_ROUTES
})
function activate(session: Parameters<typeof run>[0], manifest: MobileWebShellManifestFacts) {
return run(
session,
{ type: 'manifest-read', manifest },
{ type: 'download-staged' },
{
type: 'activated',
generationDirectory: '/cache/gen',
sessionId: 'session-downloaded',
buildId: manifest.buildId,
totalBytes: manifest.totalBytes,
elapsedMs: 9
}
)
}
it('is the manifest it downloaded, on a cold cache', () => {
const step = activate(awaitingManifest(null).session, DOWNLOADED)
expect(step.session.state.kind).toBe('ready')
expect(step.session.pageRouteGrants).toEqual(TWO_ROUTES)
})
it('is the manifest it matched, on a cached hit', () => {
const step = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: MANIFEST
})
expect(step.session.state.kind).toBe('activating')
expect(step.session.pageRouteGrants).toEqual(PAGE_ROUTES)
})
it("replaces the previous generation's entries when the generation changes", () => {
// Seed older pairs so a missed update exposes stale grants as well as empty defaults.
const first = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: MANIFEST
})
expect(first.session.pageRouteGrants).toEqual(PAGE_ROUTES)
const step = activate(
run(first.session, { type: 'retry-pressed' }, { type: 'cache-read', generation: null })
.session,
DOWNLOADED
)
expect(step.session.pageRouteGrants).toEqual(TWO_ROUTES)
})
})
@@ -8,162 +8,11 @@ import {
readySession,
run,
started,
BUNDLE_REFUSED,
LINK_LOST,
withoutRecord
BUNDLE_REFUSED
} from './mobile-web-shell-session-test-fixtures'
import { shellPageFrame } from './shell-page-frame'
const NO_BUNDLE_WALL = { kind: 'wall', verdict: { kind: 'blocked', reason: 'bundle-unavailable' } }
describe('the gates decide whether a step is taken at all', () => {
it('picks the flow back up if that status ever becomes readable', () => {
const unreadable = started({ statusReadable: false, hostCapabilities: [] })
const step = run(unreadable.session, { type: 'gates-changed', gates: gates() })
expect(step.session.state).toEqual({ kind: 'checking' })
expect(step.effects).toEqual([{ kind: 'open-cache' }])
})
})
describe('the offline rule', () => {
it('opens a cache read that lands mid-dial without asking for the manifest', () => {
const dialling = run(started().session, {
type: 'gates-changed',
gates: gates({ reachability: 'connecting' })
})
const step = run(dialling.session, { type: 'cache-read', generation: CACHED })
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(step.effects).toEqual([
{
kind: 'open-generation',
directory: CACHED.directory,
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes
}
])
})
it('restarts the flow when the host becomes reachable while offline is showing', () => {
const offline = run(started({ reachability: 'unreachable' }).session, {
type: 'cache-read',
generation: null
})
const step = run(offline.session, { type: 'gates-changed', gates: gates() })
expect(step.effects).toEqual([{ kind: 'open-cache' }])
})
})
describe('the connected flow', () => {
it('opens a same-build hit without paging, under the fresh grants', () => {
// Use unservable cached routes to prove fresh manifest grants decide the online same-build session.
const stale = { ...CACHED, routes: [{ pathname: '/h/[hostId]', grants: ['teleport'] }] }
const step = run(awaitingManifest(stale).session, { type: 'manifest-read', manifest: MANIFEST })
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
// Opening must not rewrite the manifest while the native view reads it.
expect(step.effects).toEqual([
{
kind: 'open-generation',
directory: CACHED.directory,
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes
}
])
expect(step.session.routeGrants).toEqual(['navigate'])
})
})
describe('a read the link cut short falls back to what is on disk', () => {
function manifestInFlight() {
return awaitingManifest(CACHED)
}
it('opens the cached generation when the socket drops before the reachability change does', () => {
const step = run(manifestInFlight().session, { type: 'download-failed', cause: LINK_LOST })
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(withoutRecord(step.effects)).toEqual([
{
kind: 'open-generation',
directory: CACHED.directory,
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes
}
])
const ready = run(step.session, {
type: 'activated',
generationDirectory: CACHED.directory,
sessionId: 'session-one',
buildId: CACHED.buildId,
totalBytes: CACHED.totalBytes,
elapsedMs: 12
})
expect(ready.session.state).toMatchObject({ kind: 'ready', buildId: CACHED.buildId })
})
})
describe('a displayed generation is not restarted by the gates', () => {
it.each(['connected', 'unreachable', 'connecting'] as const)(
'keeps a ready session when reachability becomes %s',
(reachability) => {
const ready = readySession()
const step = run(ready.session, { type: 'gates-changed', gates: gates({ reachability }) })
expect(step.session.state).toEqual(ready.session.state)
expect(step.effects).toEqual([])
}
)
it('keeps a wall and a terminal failure', () => {
const wall = started({ hostCapabilities: [] })
expect(run(wall.session, { type: 'gates-changed', gates: gates() }).effects).toEqual([])
const failed = run(awaitingManifest(null).session, {
type: 'download-failed',
cause: BUNDLE_REFUSED
})
expect(run(failed.session, { type: 'gates-changed', gates: gates() }).effects).toEqual([])
})
})
describe('recovery follows the shell view contract', () => {
it('takes a recovery through the gate rather than back to a manifest check', () => {
const ready = readySession()
// Store unreadable reconnect gates under ready without restarting the running workspace.
const stale = run(ready.session, {
type: 'gates-changed',
gates: gates({ statusReadable: false, hostCapabilities: [] })
})
expect(stale.session.state).toMatchObject({ kind: 'ready' })
const step = run(stale.session, { type: 'shell-failed', reason: 'generation-unreadable' })
expect(step.session.state).toEqual({
kind: 'failed',
reason: 'status-unreadable',
retriedOnce: true
})
expect(step.effects).toEqual([{ kind: 'delete-cache' }])
const rearmed = run(step.session, { type: 'gates-changed', gates: gates() })
expect(rearmed.session.state).toEqual({ kind: 'checking' })
expect(rearmed.effects).toEqual([{ kind: 'open-cache' }])
})
it('walls a ready page as soon as the host stops serving a bundle', () => {
const stale = run(readySession().session, {
type: 'gates-changed',
gates: gates({ hostCapabilities: [] })
})
expect(stale.session.state).toEqual(NO_BUNDLE_WALL)
})
it('deletes the suspect cache and reads it again when the recovery lands mid-reconnect', () => {
const dialling = run(readySession().session, {
type: 'gates-changed',
gates: gates({ reachability: 'connecting' })
})
const step = run(dialling.session, { type: 'shell-failed', reason: 'generation-unreadable' })
expect(step.session.state).toEqual({ kind: 'checking' })
expect(step.effects).toEqual([{ kind: 'delete-cache' }, { kind: 'open-cache' }])
expect(run(step.session, { type: 'gates-changed', gates: gates() }).effects).toEqual([
{ kind: 'open-cache' }
])
})
it('is terminal the second time an unreadable generation needs a refetch', () => {
const unreadable = { type: 'shell-failed', reason: 'generation-unreadable' } as const
const first = run(readySession().session, unreadable)
@@ -263,24 +112,6 @@ describe('a result from a superseded flow reports into nothing', () => {
])
})
it('drops the manifest of a run the socket drop replaced, so no download is asked for', () => {
const first = awaitingManifest(null)
const restarted = run(first.session, {
type: 'gates-changed',
gates: gates({ reachability: 'unreachable' })
})
const stale = run(restarted.session, {
type: 'manifest-read',
flow: first.session.flow,
manifest: MANIFEST
})
expect(stale.effects).toEqual([])
expect(stale.session.state).toEqual({ kind: 'checking' })
const current = run(stale.session, { type: 'cache-read', generation: null })
expect(current.session.state).toEqual({ kind: 'offline' })
expect(current.effects).toEqual([])
})
it('keeps a workspace on screen when the manifest read the drop abandoned finally rejects', () => {
// Settle the abandoned RPC only after socket loss opens cache, exposing any missing flow guard.
const inFlight = awaitingManifest(CACHED)
@@ -308,20 +139,6 @@ describe('a result from a superseded flow reports into nothing', () => {
})
expect(late.session.state).toEqual(ready.session.state)
})
it('applies a remount of the current flow and ignores one from a replaced run', () => {
const ready = readySession()
const remounting = run(ready.session, { type: 'shell-failed', reason: 'render-process-gone' })
const stale = run(remounting.session, {
type: 'remounted',
flow: remounting.session.flow - 1,
sessionId: 'session-stale'
})
expect(stale.session.state).toEqual(ready.session.state)
expect(
run(stale.session, { type: 'remounted', sessionId: 'session-two' }).session.state
).toMatchObject({ sessionId: 'session-two' })
})
})
describe('a reconnect does not refill the remount budget', () => {
@@ -356,98 +173,10 @@ describe('only the state that mounted the view hears the view', () => {
{ kind: 'read-manifest' }
])
})
it('leaves a wall standing when a view that is no longer mounted reports a failure', () => {
const wall = started({ hostCapabilities: [] })
const step = run(wall.session, { type: 'shell-failed', reason: 'isolation-unavailable' })
expect(step.session.state).toEqual(wall.session.state)
expect(step.effects).toEqual([])
})
})
describe('a gates change that says nothing new starts nothing', () => {
it('leaves a check in flight alone rather than sweeping and reading a second time', () => {
const checking = started()
const again = run(checking.session, { type: 'gates-changed', gates: gates() })
expect(again.effects).toEqual([])
expect(again.session.flow).toBe(checking.session.flow)
})
it('keeps a first open checking while the dial retries, then says offline when it stops', () => {
const retrying = gates({ reachability: 'unreachable', retrying: true })
const waiting = run(started(retrying).session, { type: 'cache-read', generation: null })
expect(waiting.session.state).toEqual({ kind: 'checking' })
const gaveUp = run(waiting.session, {
type: 'gates-changed',
gates: gates({ reachability: 'unreachable' })
})
expect(gaveUp.effects).toEqual([{ kind: 'open-cache' }])
const offline = run(gaveUp.session, { type: 'cache-read', generation: null })
expect(offline.session.state).toEqual({ kind: 'offline' })
})
it('still opens a cached page at once while the dial retries', () => {
const retrying = gates({ reachability: 'unreachable', retrying: true })
const step = run(started(retrying).session, { type: 'cache-read', generation: CACHED })
const offline = gates({ reachability: 'unreachable' })
const unretried = run(started(offline).session, { type: 'cache-read', generation: CACHED })
expect(step.session.state).toEqual(unretried.session.state)
expect(step.effects).toEqual(unretried.effects)
expect(step.session.state.kind).toBe('activating')
})
it('holds the offline screen through a reconnect cycle that never reaches the host', () => {
const offline = run(started({ reachability: 'unreachable' }).session, {
type: 'cache-read',
generation: null
})
const cycled = run(
offline.session,
{ type: 'gates-changed', gates: gates({ reachability: 'unreachable' }) },
{ type: 'gates-changed', gates: gates({ reachability: 'unreachable' }) }
)
expect(cycled.effects).toEqual([])
expect(cycled.session.state).toEqual({ kind: 'offline' })
})
it('restarts on the verdict that changed, not on the object that was rebuilt', () => {
const checking = started({ statusPending: true })
const settled = run(checking.session, { type: 'gates-changed', gates: gates() })
expect(settled.effects).toEqual([{ kind: 'open-cache' }])
})
it('walls a check in flight when the host stops serving a bundle', () => {
const checking = started()
const step = run(checking.session, {
type: 'gates-changed',
gates: gates({ hostCapabilities: [] })
})
expect(step.session.state).toEqual(NO_BUNDLE_WALL)
})
})
// 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('arms nothing when the page spoke first, because there is nothing left to wait for', () => {
const step = run(readySession().session, { type: 'page-ready' }, { type: 'document-loaded' })
expect(step.effects).toEqual([])
expect(step.session.pageReady).toBe(true)
})
it('remounts the same files when the wait expires', () => {
const ready = run(readySession().session, { type: 'document-loaded' })
const step = run(ready.session, { type: 'page-ready-deadline' })
expect(step.effects).toEqual([{ kind: 'remount' }])
expect(step.session.retriedOnce).toBe(false)
})
it('retires both waits once the page speaks', () => {
expect(run(readySession().session, { type: 'page-ready' }).effects).toEqual([
{ kind: 'cancel-deadlines' }
])
})
it('does nothing when the wait expires after the page has spoken', () => {
const step = run(
readySession().session,
@@ -459,26 +188,6 @@ describe('the page has to speak for the document that loaded', () => {
expect(step.session.state.kind).toBe('ready')
})
it('drops the expiry of a wait a restarted flow left behind', () => {
const ready = run(readySession().session, { type: 'document-loaded' })
const step = run(
ready.session,
{ type: 'retry-pressed' },
{ type: 'page-ready-deadline', flow: ready.session.flow }
)
expect(step.session.state.kind).toBe('checking')
expect(step.session.retriedOnce).toBe(false)
})
it('makes the second document prove itself, rather than riding the first one word', () => {
const spoken = run(readySession().session, { type: 'page-ready' })
const remounted = run(spoken.session, { type: 'remounted', sessionId: 'session-two' })
expect(remounted.session.pageReady).toBe(false)
expect(run(remounted.session, { type: 'document-loaded' }).effects).toEqual([
{ kind: 'await-page-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
@@ -502,42 +211,10 @@ describe('the view has to finish the document it was given', () => {
const step = run(started.session, { type: 'document-load-deadline' })
expect(step.effects).toEqual([{ kind: 'remount' }])
})
it('does nothing once the document finished or the page spoke', () => {
const loaded = run(readySession().session, { type: 'document-loaded' })
expect(run(loaded.session, { type: 'document-load-deadline' }).effects).toEqual([])
const spoke = run(readySession().session, { type: 'page-ready' })
expect(run(spoke.session, { type: 'document-load-deadline' }).session.state.kind).toBe('ready')
})
it('drops the wait a replaced document left behind', () => {
const ready = readySession()
const armed = ready.session.flow
const started = run(ready.session, { type: 'document-started' })
const step = run(started.session, { type: 'document-load-deadline', flow: armed })
expect(step.effects).toEqual([])
expect(step.session.state.kind).toBe('ready')
})
})
// Neither WebView commit nor page ready proves paint; keep the cover until the page reports a frame.
describe('the page reporting a frame on screen', () => {
it('keeps the frame covered past ready until the report', () => {
const spoken = run(readySession().session, { type: 'page-ready' })
expect(spoken.session.pagePainted).toBe(false)
expect(shellPageFrame(spoken.session)).toBe('unpainted')
const painted = run(spoken.session, { type: 'page-painted' })
expect(painted.session.pagePainted).toBe(true)
expect(shellPageFrame(painted.session)).toBe('painted')
})
it('makes a remounted document report its own frame', () => {
const painted = run(readySession().session, { type: 'page-ready' }, { type: 'page-painted' })
const remounted = run(painted.session, { type: 'remounted', sessionId: 'session-two' })
expect(remounted.session.pagePainted).toBe(false)
expect(shellPageFrame(remounted.session)).toBe('unpainted')
})
it('makes the document that replaced a painted one inside this mount report its own frame', () => {
const painted = run(readySession().session, { type: 'page-ready' }, { type: 'page-painted' })
expect(shellPageFrame(painted.session)).toBe('painted')
@@ -547,29 +224,6 @@ describe('the page reporting a frame on screen', () => {
expect(shellPageFrame(reasked.session)).toBe('unpainted')
expect(shellPageFrame(run(reasked.session, { type: 'page-painted' }).session)).toBe('painted')
})
it('retires the wait the document it replaced armed', () => {
const loaded = run(readySession().session, { type: 'document-loaded' })
expect(loaded.effects).toEqual([{ kind: 'await-page-ready' }])
const armed = loaded.session.flow
const spoken = run(loaded.session, { type: 'page-ready' })
const restarted = run(spoken.session, { type: 'document-started' })
const expired = run(restarted.session, { type: 'page-ready-deadline', flow: armed })
expect(expired.session.state.kind).toBe('ready')
const reloaded = run(restarted.session, { type: 'document-loaded' })
expect(reloaded.effects).toEqual([{ kind: 'await-page-ready' }])
})
it('keeps the frame of a document that repeats its own handshake', () => {
const painted = run(
readySession().session,
{ type: 'page-ready' },
{ type: 'page-painted' },
{ type: 'page-ready' }
)
expect(painted.session.pagePainted).toBe(true)
expect(shellPageFrame(painted.session)).toBe('painted')
})
})
describe('a cached page opened before the verdict', () => {
@@ -600,27 +254,6 @@ describe('a cached page opened before the verdict', () => {
expect(staged.effects).toEqual([{ kind: 'stage-update' }])
})
it('lets the desktop manifest decide when the verdict puts it outside the window', () => {
const blocked = run(openedWhileDialling().session, {
type: 'gates-changed',
gates: gates({ hostStatus: { protocolVersion: 10, minCompatibleMobileVersion: 99 } })
})
expect(blocked.session.state).toEqual({ kind: 'checking' })
expect(blocked.effects).toEqual([{ kind: 'open-cache' }])
})
it('shows the status failure when the status it waited for cannot be read', () => {
const unreadable = run(openedWhileDialling().session, {
type: 'gates-changed',
gates: gates({ statusReadable: false, hostCapabilities: [] })
})
expect(unreadable.session.state).toEqual({
kind: 'failed',
reason: 'status-unreadable',
retriedOnce: false
})
})
it('walls a page that already talked when a new connection puts it outside the window', () => {
const talked = run(openedWhileDialling().session, { type: 'gates-changed', gates: gates() })
const reconnected = run(
@@ -1,228 +0,0 @@
import { describe, expect, it } from 'vitest'
import {
BUNDLE_REFUSED,
CACHED,
CACHED_BELOW_HOST_FLOOR,
LINK_LOST,
MANIFEST_WIRE,
awaitingManifest,
gates,
manifestFacts,
run
} from './mobile-web-shell-session-test-fixtures'
import type { MobileWebShellStep } from './mobile-web-shell-session-contract'
import type { MobileWebShellUpdateFailureFacts } from './mobile-web-shell-update-failure'
// Require one record per failed-read outcome with cause/builds/verdict; release console logs cannot provide this evidence.
const NEWER = manifestFacts({ ...MANIFEST_WIRE, buildId: 'c'.repeat(64) })
function recorded(step: MobileWebShellStep): MobileWebShellUpdateFailureFacts[] {
return step.effects.flatMap((effect) =>
effect.kind === 'record-update-failure' ? [effect.failure] : []
)
}
function refusedUnder(
patch: Parameters<typeof gates>[0],
cached = CACHED,
cause = BUNDLE_REFUSED
): MobileWebShellStep {
const fetching = run(awaitingManifest(cached).session, { type: 'manifest-read', manifest: NEWER })
const moved = run(fetching.session, { type: 'gates-changed', gates: gates(patch) })
return run(moved.session, { type: 'download-failed', cause })
}
describe('every exit from a failed update read leaves one record', () => {
it('nothing on disk: the failure screen, with the offered generation named', () => {
const fetching = run(awaitingManifest(null).session, { type: 'manifest-read', manifest: NEWER })
const step = run(fetching.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
expect(step.session.state).toMatchObject({ kind: 'failed', reason: 'download-failed' })
expect(recorded(step)).toEqual([
{
reason: 'asset-checksum-mismatch',
hostCode: null,
offeredBuildId: NEWER.buildId,
cachedBuildId: null,
outcome: 'failed',
wall: null
}
])
})
it('the manifest read itself failed: nothing was offered, the cached generation opens', () => {
const step = run(awaitingManifest(CACHED).session, {
type: 'download-failed',
cause: { reason: 'host-refused', hostCode: 'mobile_web_bundle_read_limited' }
})
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(recorded(step)).toEqual([
{
reason: 'host-refused',
hostCode: 'mobile_web_bundle_read_limited',
offeredBuildId: null,
cachedBuildId: CACHED.buildId,
outcome: 'opened-cached',
wall: null
}
])
})
it('a refused download falls back to the cached generation under the notice', () => {
const step = refusedUnder({})
expect(step.session.updateNotice).toBe('update-failed')
expect(recorded(step)).toEqual([
{
reason: 'asset-checksum-mismatch',
hostCode: null,
offeredBuildId: NEWER.buildId,
cachedBuildId: CACHED.buildId,
outcome: 'opened-cached',
wall: null
}
])
})
it('a link that went is recorded too, though the screen carries no notice for it', () => {
const step = refusedUnder({}, CACHED, LINK_LOST)
expect(step.session.updateNotice).toBeNull()
expect(recorded(step)).toMatchObject([{ reason: 'connection-lost', outcome: 'opened-cached' }])
})
it('no client to ask is recorded as its own reason', () => {
const step = refusedUnder({}, CACHED, { reason: 'no-connection', hostCode: null })
expect(recorded(step)).toMatchObject([{ reason: 'no-connection', outcome: 'opened-cached' }])
})
it('a cached generation the host has moved past is walled, and the verdict is kept', () => {
const step = refusedUnder({}, CACHED_BELOW_HOST_FLOOR)
expect(step.session.state).toMatchObject({ kind: 'wall' })
expect(recorded(step)).toMatchObject([
{ outcome: 'wall', wall: 'bundle-too-old-for-host', cachedBuildId: CACHED.buildId }
])
})
it('a cached generation that never carried this route shows the download failure', () => {
const step = refusedUnder({}, { ...CACHED, routes: [] })
expect(step.session.state).toMatchObject({ kind: 'failed', reason: 'download-failed' })
expect(recorded(step)).toMatchObject([{ outcome: 'failed', wall: null }])
})
it('gates gone offline under the fetch open the cache unjudged', () => {
const step = refusedUnder({ reachability: 'unreachable' }, CACHED_BELOW_HOST_FLOOR)
expect(step.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(recorded(step)).toMatchObject([{ outcome: 'opened-cached', wall: null }])
})
it('gates with an unreadable status answer the status failure', () => {
const step = refusedUnder({ statusReadable: false })
expect(step.session.state).toMatchObject({ kind: 'failed', reason: 'status-unreadable' })
expect(recorded(step)).toMatchObject([{ outcome: 'failed' }])
})
it('gates that dropped the bundle capability wall the host', () => {
const step = refusedUnder({ hostCapabilities: [] })
expect(step.session.state).toMatchObject({ kind: 'wall' })
expect(recorded(step)).toMatchObject([{ outcome: 'wall', wall: 'bundle-unavailable' }])
})
it('gates still dialling or pending open the cached generation before the verdict', () => {
expect(recorded(refusedUnder({ reachability: 'connecting' }))).toMatchObject([
{ outcome: 'opened-cached' }
])
expect(recorded(refusedUnder({ statusPending: true }))).toMatchObject([
{ outcome: 'opened-cached' }
])
})
it('a stale flow reports into nothing and records nothing', () => {
const fetching = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: NEWER
})
const step = run(fetching.session, {
type: 'download-failed',
flow: fetching.session.flow - 1,
cause: BUNDLE_REFUSED
})
expect(recorded(step)).toEqual([])
})
it('a new flow forgets the generation the last one was offered', () => {
const fetching = run(awaitingManifest(null).session, { type: 'manifest-read', manifest: NEWER })
const failed = run(fetching.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
const retried = run(
failed.session,
{ type: 'retry-pressed' },
{ type: 'cache-read', generation: null }
)
const step = run(retried.session, { type: 'download-failed', cause: LINK_LOST })
expect(recorded(step)).toMatchObject([{ offeredBuildId: null }])
})
})
describe('a newer generation committed clears the record, and nothing else does', () => {
function forgets(step: MobileWebShellStep): boolean {
return step.effects.some((effect) => effect.kind === 'forget-update-failures')
}
function activated(buildId: string) {
return {
type: 'activated',
generationDirectory: '/cache/gen',
sessionId: 'session-one',
buildId,
totalBytes: 1,
elapsedMs: 1
} as const
}
it('forgets once the offered generation lands', () => {
const fetching = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: NEWER
})
const step = run(fetching.session, { type: 'download-staged' }, activated(NEWER.buildId))
expect(step.session.state).toMatchObject({ kind: 'ready', buildId: NEWER.buildId })
expect(forgets(step)).toBe(true)
})
it('forgets when the host moved between the manifest read and the fetch', () => {
// Fetch rereads the manifest, so a committed download can be newer than the offered build and must still clear failure history.
const MOVED = 'd'.repeat(64)
const fetching = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: NEWER
})
const step = run(fetching.session, { type: 'download-staged' }, activated(MOVED))
expect(step.session.state).toMatchObject({ kind: 'ready', buildId: MOVED })
expect(forgets(step)).toBe(true)
})
it('keeps the record when the fallback opens the cached generation', () => {
const fetching = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: NEWER
})
const failed = run(fetching.session, { type: 'download-failed', cause: BUNDLE_REFUSED })
expect(forgets(run(failed.session, activated(CACHED.buildId)))).toBe(false)
})
it('keeps it for a same-build cache hit, which committed nothing', () => {
const hit = run(awaitingManifest(CACHED).session, {
type: 'manifest-read',
manifest: manifestFacts(MANIFEST_WIRE)
})
expect(forgets(run(hit.session, activated(CACHED.buildId)))).toBe(false)
})
it('keeps it for an offline open', () => {
const offline = run(
awaitingManifest(null).session,
{ type: 'gates-changed', gates: gates({ reachability: 'unreachable' }) },
{ type: 'retry-pressed' },
{ type: 'cache-read', generation: CACHED }
)
expect(offline.session.state).toEqual({ kind: 'activating', source: 'cache' })
expect(forgets(run(offline.session, activated(CACHED.buildId)))).toBe(false)
})
})
@@ -19,12 +19,6 @@ describe('a failed document', () => {
})
})
it('still remounts silently when the renderer dies after a page failure was remounted', () => {
const lost = run(readySession().session, DOCUMENT_FAILED, REMOUNTED, RENDERER_GONE)
expect(lost.effects).toEqual([{ kind: 'remount' }])
expect(lost.session.state.kind).toBe('ready')
})
// Refilling on paint would loop a page that paints and then faults: remount, paint, fault, forever.
it('fails visibly when the remounted page paints and then faults again', () => {
const painted = { type: 'page-painted' } as const
@@ -39,21 +33,9 @@ describe('a failed document', () => {
expect(failed.effects).toEqual([])
expect(failed.session.state).toMatchObject({ kind: 'failed', reason: 'document-load-failed' })
})
it('still remounts a failed document after a renderer-loss remount', () => {
const failed = run(readySession().session, RENDERER_GONE, REMOUNTED, DOCUMENT_FAILED)
expect(failed.effects).toEqual([{ kind: 'remount' }])
})
})
describe('try again after a failed document', () => {
it('deletes the files that failed before checking the host again', () => {
const failed = run(readySession().session, DOCUMENT_FAILED, REMOUNTED, DOCUMENT_FAILED)
const retried = run(failed.session, { type: 'retry-pressed' })
expect(retried.effects).toEqual([{ kind: 'delete-cache' }, { kind: 'open-cache' }])
expect(retried.session.pageRemountedOnce).toBe(false)
})
it('keeps the cache when the renderer was what failed', () => {
const failed = run(readySession().session, RENDERER_GONE, REMOUNTED, RENDERER_GONE)
expect(failed.session.state).toMatchObject({ kind: 'failed', reason: 'render-process-gone' })
@@ -1,270 +1,10 @@
import { describe, expect, it, vi } from 'vitest'
import { buildConnectionDiagnosticsReport } from '../diagnostics/connection-diagnostics-report'
import type { ConnectionLogEntry } from '../transport/types'
import {
CACHED,
MANIFEST,
createMobileWebShellSession,
gates,
ROUTE,
stamp
} from './mobile-web-shell-session-test-fixtures'
import { reduceMobileWebShellSession } from './mobile-web-shell-session'
import type {
MobileWebShellSession,
MobileWebShellSessionEvent
} from './mobile-web-shell-session-contract'
import { connectionLogStore } from '../transport/persisted-connection-log-store'
import { bridgeDiagnosticLine, frameWithoutHostLine } from './shell-bridge-log-lines'
import { recordShellLifecycleLine, type ShellLifecycleLine } from './shell-lifecycle-line-recorder'
import {
EMPTY_SHELL_LOG_TRACE,
pageFaultLine,
shellSessionStepLines,
shellStallLine,
traceShellStep,
type ShellLogTrace
} from './shell-lifecycle-log'
import { pageFaultLine } from './shell-lifecycle-log'
vi.mock('@react-native-async-storage/async-storage', () => ({
default: { getItem: vi.fn(async () => null), setItem: vi.fn(async () => undefined) }
}))
type Pending = Parameters<typeof stamp>[1]
type Replayed = {
session: MobileWebShellSession
trace: ShellLogTrace
lines: ShellLifecycleLine[]
}
function replay(
events: readonly Pending[],
from: Omit<Replayed, 'lines'> = {
session: createMobileWebShellSession(ROUTE),
trace: EMPTY_SHELL_LOG_TRACE
}
): Replayed {
let { session, trace } = from
const lines: ShellLifecycleLine[] = []
for (const pending of events) {
const event: MobileWebShellSessionEvent = stamp(session.flow, pending)
const next = reduceMobileWebShellSession(session, event).session
trace = traceShellStep(trace, session, event, next)
lines.push(...shellSessionStepLines(session, event, next, trace))
session = next
}
return { session, trace, lines }
}
function stall(replayed: Omit<Replayed, 'lines'>): ShellLifecycleLine | null {
return shellStallLine(replayed.session.state, replayed.session, replayed.trace)
}
const ACTIVATED = {
type: 'activated',
generationDirectory: '/Users/someone/Library/Caches/gen-1',
sessionId: 'session-one',
buildId: MANIFEST.buildId,
totalBytes: MANIFEST.totalBytes,
elapsedMs: 1234
} as const
const DOWNLOAD_OPEN: readonly Pending[] = [
{ type: 'gates-changed', gates: gates() },
{ type: 'cache-read', generation: null },
{ type: 'manifest-read', manifest: MANIFEST },
{
type: 'fetch-progress',
completedAssets: 1,
totalAssets: MANIFEST.totalAssets,
receivedBytes: 10,
totalBytes: MANIFEST.totalBytes
},
{
type: 'fetch-progress',
completedAssets: 2,
totalAssets: MANIFEST.totalAssets,
receivedBytes: 20,
totalBytes: MANIFEST.totalBytes
},
{ type: 'download-staged' },
ACTIVATED
]
function present(line: ShellLifecycleLine | null): ShellLifecycleLine[] {
expect(line).not.toBeNull()
return line === null ? [] : [line]
}
function summary(lines: readonly ShellLifecycleLine[]): string[] {
return lines.map(
(line) => `${line.code} ${line.message}${line.detail ? ` | ${line.detail}` : ''}`
)
}
const PAGE_LOAD: readonly Pending[] = [
{ type: 'document-started' },
{ type: 'document-loaded' },
{ type: 'page-ready' }
]
const BUILD = MANIFEST.buildId.slice(0, 8)
describe('shell lifecycle log lines', () => {
it('writes exactly one line for a healthy cached open: the paint', () => {
const { lines } = replay([
{ type: 'gates-changed', gates: gates() },
{ type: 'cache-read', generation: CACHED },
{ type: 'manifest-read', manifest: MANIFEST },
ACTIVATED,
...PAGE_LOAD,
{ type: 'page-ready' },
{ type: 'page-painted' },
{ type: 'page-painted' },
{ type: 'page-back-claim', claimed: true }
])
expect(summary(lines)).toEqual([
`web-shell-page Web shell: page painted | source=cache build=${BUILD} activatedMs=1234`
])
})
it('adds only the download milestones to a downloading open, and no progress ticks', () => {
const { lines } = replay([...DOWNLOAD_OPEN, ...PAGE_LOAD, { type: 'page-painted' }])
expect(summary(lines)).toEqual([
`web-shell-flow Web shell: downloading app | ${MANIFEST.totalAssets} assets, ${MANIFEST.totalBytes} bytes`,
'web-shell-flow Web shell: activating app | source=download',
`web-shell-page Web shell: page painted | source=download build=${BUILD} activatedMs=1234`
])
expect(JSON.stringify(lines)).not.toContain('/Users/someone')
})
it('logs the wall a host with no page earns', () => {
const { session, lines } = replay([
{ type: 'gates-changed', gates: gates({ hostCapabilities: [] }) }
])
expect(session.state.kind).toBe('wall')
expect(summary(lines)).toEqual([
'web-shell-flow Web shell: blocked by version check | reason=bundle-unavailable'
])
})
it('logs a missed ready deadline but not the remount it earns', () => {
const opened = replay(DOWNLOAD_OPEN)
const { lines } = replay([{ type: 'document-loaded' }, { type: 'page-ready-deadline' }], opened)
expect(summary(lines)).toEqual([
'web-shell-page Web shell: page never said ready before the deadline'
])
})
it('logs a document that never finished loading but not the remount it earns', () => {
const opened = replay(DOWNLOAD_OPEN)
const { lines } = replay(
[{ type: 'document-started' }, { type: 'document-load-deadline' }],
opened
)
expect(summary(lines)).toEqual([
'web-shell-page Web shell: document never finished loading before the deadline'
])
})
it('logs a view failure but not the remount it earns', () => {
const opened = replay(DOWNLOAD_OPEN)
const { lines } = replay(
[
{ type: 'shell-failed', reason: 'render-process-gone' },
{ type: 'remounted', sessionId: 'session-two' }
],
opened
)
expect(summary(lines)).toEqual([
'web-shell-page Web shell: page load failed | reason=render-process-gone'
])
})
it('ignores results from a superseded flow', () => {
const opened = replay(DOWNLOAD_OPEN)
const { lines } = replay(
[
{ type: 'page-ready-deadline', flow: opened.session.flow - 1 },
{ ...ACTIVATED, flow: 0 }
],
opened
)
expect(lines).toEqual([])
})
it('logs a failed download with its closed reason code', () => {
const { lines } = replay([
{ type: 'gates-changed', gates: gates() },
{ type: 'cache-read', generation: null },
{ type: 'download-failed', cause: { reason: 'connection-lost', hostCode: null } }
])
expect(summary(lines)).toEqual([
'web-shell-flow Web shell: app download failed | reason=connection-lost',
'web-shell-flow Web shell: failed | reason=download-failed retried=no'
])
})
})
describe('shell stall lines', () => {
it('names what a checking session waits on: the gates, then the cache', () => {
const fresh = replay([])
expect(stall(fresh)).toMatchObject({
code: 'web-shell-stalled',
message: 'Web shell: still checking host after 15s',
detail: 'gates=none cache=unread'
})
expect(
stall(replay([{ type: 'gates-changed', gates: gates({ reachability: 'connecting' }) }]))
).toMatchObject({ detail: 'gates=dialling cache=unread' })
const opened = replay([{ type: 'gates-changed', gates: gates() }])
expect(opened.session.state.kind).toBe('checking')
expect(stall(opened)).toMatchObject({ detail: 'gates=open cache=unread' })
// With empty cache, trace alone distinguishes a manifest wait from an unfinished cache read.
const awaitingManifest = replay([{ type: 'cache-read', generation: null }], opened)
expect(stall(awaitingManifest)).toMatchObject({ detail: 'gates=open cache=read' })
})
it('names how far a stalled download got', () => {
const fetching = replay(DOWNLOAD_OPEN.slice(0, 4))
expect(stall(fetching)).toMatchObject({
message: 'Web shell: download made no progress for 15s',
detail: `assets=1/${MANIFEST.totalAssets} bytes=10/${MANIFEST.totalBytes}`
})
})
it('names an activation that never finished', () => {
expect(stall(replay(DOWNLOAD_OPEN.slice(0, 6)))).toMatchObject({
message: 'Web shell: still activating after 15s',
detail: 'source=download'
})
})
it('tells a page that keeps refusing init from one that took it and never drew', () => {
const opened = replay(DOWNLOAD_OPEN)
expect(stall(opened)).toMatchObject({
message: 'Web shell: page has not drawn after 15s',
detail: `build=${BUILD} page ready=no readyAsks=0 documentLoaded=no`
})
const refusing = replay([...PAGE_LOAD, { type: 'page-ready' }, { type: 'page-ready' }], opened)
expect(stall(refusing)).toMatchObject({
detail: `build=${BUILD} page ready=yes readyAsks=3 documentLoaded=yes`
})
const reloaded = replay([{ type: 'document-started' }, { type: 'page-ready' }], refusing)
expect(stall(reloaded)).toMatchObject({
detail: `build=${BUILD} page ready=yes readyAsks=1 documentLoaded=no`
})
expect(stall(replay([{ type: 'page-painted' }], reloaded))).toBeNull()
})
it('stays quiet for states nobody waits in', () => {
expect(
stall(replay([{ type: 'gates-changed', gates: gates({ hostCapabilities: [] }) }]))
).toBeNull()
})
})
describe('shell failure details', () => {
it('keeps device paths out of a page fault', () => {
expect(
@@ -276,119 +16,3 @@ describe('shell failure details', () => {
).toBe('TypeError: x is undefined at [path]')
})
})
describe('recording shell lines', () => {
it('writes a flapping host line once until a different shell line is written', () => {
const host = 'flapping-host'
const checking = replay([
{ type: 'gates-changed', gates: gates({ reachability: 'unreachable' }) },
{ type: 'cache-read', generation: null },
{ type: 'gates-changed', gates: gates({ reachability: 'connecting' }) }
]).lines
expect(summary(checking)).toEqual([
'web-shell-flow Web shell: host unreachable and no app cached',
'web-shell-flow Web shell: checking host'
])
for (let cycle = 0; cycle < 3; cycle += 1) {
for (const line of checking) {
recordShellLifecycleLine(host, line)
}
}
const messages = () => connectionLogStore.get(host).map((entry) => entry.message)
expect(messages()).toEqual([
'Web shell: host unreachable and no app cached',
'Web shell: checking host'
])
recordShellLifecycleLine(host, frameWithoutHostLine({ clientReady: true, snapshotReady: true }))
recordShellLifecycleLine(host, checking[1]!)
recordShellLifecycleLine('other-host', checking[1]!)
expect(messages().slice(2)).toEqual([
'Web shell: page frame with no bridge host',
'Web shell: checking host'
])
expect(connectionLogStore.get('other-host')).toHaveLength(1)
})
})
describe('shell lifecycle lines in the exported report', () => {
function entries(lines: readonly ShellLifecycleLine[]): ConnectionLogEntry[] {
return lines.map((line, index) => ({ id: `e${index}`, ts: 1_000 + index * 1_000, ...line }))
}
it('shows where a connected session stalled without changing the connection verdict', () => {
const opened = replay(DOWNLOAD_OPEN)
const page = replay(PAGE_LOAD, opened)
const report = buildConnectionDiagnosticsReport({
hostName: 'Desk',
endpoint: 'ws://192.168.1.2:6768',
state: 'connected',
reconnectAttempts: 0,
lastConnectedAt: 500,
platform: 'ios',
appVersion: '0.0.56',
bridgeProtocolVersion: 1,
entries: entries([...opened.lines, ...page.lines, ...present(stall(page))]),
nowMs: 60_000
})
expect(report).toContain('Bridge protocol: 1')
expect(report).toContain('Likely cause: Connection is healthy.')
expect(report).toContain('[web-shell-flow] Web shell: activating app')
expect(report).toContain(
`[warn] [web-shell-stalled] Web shell: page has not drawn after 15s — build=${BUILD} page ready=yes readyAsks=1 documentLoaded=yes`
)
})
it('never reads shell lines as a connection failure', () => {
const failed = replay([
{ type: 'gates-changed', gates: gates() },
{ type: 'cache-read', generation: null },
{ type: 'download-failed', cause: { reason: 'connection-lost', hostCode: null } }
])
const report = buildConnectionDiagnosticsReport({
hostName: 'Desk',
endpoint: 'ws://192.168.1.2:6768',
state: 'disconnected',
reconnectAttempts: 1,
lastConnectedAt: null,
platform: 'ios',
appVersion: '0.0.56',
bridgeProtocolVersion: 1,
entries: entries([
...failed.lines,
...present(stall(replay(DOWNLOAD_OPEN.slice(0, 6)))),
...present(stall(replay([]))),
...present(bridgeDiagnosticLine({ kind: 'refused', refusal: 'oversized' })),
frameWithoutHostLine({ clientReady: false, snapshotReady: false })
]),
nowMs: 60_000
})
expect(report).toContain(
'Likely cause: No single failure cause can be determined from the recorded events.'
)
})
it('leaves an earlier connection failure as the likely cause', () => {
const timeout: ConnectionLogEntry = {
id: 'timeout',
ts: 500,
level: 'error',
code: 'connect-timeout',
message: 'WebSocket connect timeout'
}
const report = buildConnectionDiagnosticsReport({
hostName: 'Desk',
endpoint: 'ws://192.168.1.2:6768',
state: 'disconnected',
reconnectAttempts: 1,
lastConnectedAt: null,
platform: 'ios',
appVersion: '0.0.56',
bridgeProtocolVersion: 1,
entries: [timeout, ...entries(replay(DOWNLOAD_OPEN).lines)],
nowMs: 60_000
})
expect(report).toContain(
'Likely cause: The saved direct endpoint did not answer before the connection timeout.'
)
})
})
@@ -1,44 +0,0 @@
import { describe, expect, it } from 'vitest'
import type { MobileWebShellSessionState } from './mobile-web-shell-session-contract'
import { shellPageFrame } from './shell-page-frame'
const READY: MobileWebShellSessionState = {
kind: 'ready',
generationDirectory: '/cache/gen',
sessionId: 'session-a',
buildId: 'build-a',
totalBytes: 1,
elapsedMs: 1,
compat: {
schemaVersion: 1,
runtimeProtocolVersion: 1,
minCompatibleRuntimeProtocolVersion: 1,
pageVersion: 1
}
}
function frame(patch: { state?: MobileWebShellSessionState; pagePainted?: boolean }) {
return shellPageFrame({ state: patch.state ?? READY, pagePainted: patch.pagePainted ?? false })
}
describe('how long the shell keeps its own frame up', () => {
it('has nothing to cover before a generation is on screen', () => {
for (const state of [
{ kind: 'checking' },
{ kind: 'activating', source: 'download' },
{ kind: 'offline' },
{ kind: 'route-unavailable' }
] as const satisfies readonly MobileWebShellSessionState[]) {
expect(frame({ state }), state.kind).toBe('pending')
}
})
it('covers a mounted view until the page reports a frame, handshake or not', () => {
// Ready precedes tree construction; keep the cover over the empty view until paint.
expect(frame({})).toBe('unpainted')
})
it('uncovers on the page reporting a frame', () => {
expect(frame({ pagePainted: true })).toBe('painted')
})
})
@@ -9,16 +9,11 @@ import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest'
import type { OrcaMobileWebShellViewHandle } from '../../modules/orca-mobile-web-shell/src'
import { BRIDGE_NATIVE_VERB_NAMES } from './bridge/bridge-native-verbs'
import {
BRIDGE_HAPTICS_GRANT,
BRIDGE_HAPTICS_NOTIFY,
type BridgeHapticsKind
} from './bridge/bridge-haptics-notify'
import { BRIDGE_HAPTICS_GRANT, type BridgeHapticsKind } from './bridge/bridge-haptics-notify'
import { BRIDGE_SCREENCAST_BINARY_GRANT } from './bridge/bridge-screencast-grant'
import { BRIDGE_BACK_CLAIM_NOTIFY, BRIDGE_BACK_FRAME } from './bridge/bridge-page-back'
import {
BRIDGE_FAULT_GRANT,
BRIDGE_NAVIGATE_BACK_NOTIFY,
readBridgeHostMessage,
type BridgeHostMessage
} from './bridge/bridge-envelope'
@@ -44,7 +39,6 @@ import {
useMobileWebShellBridge,
type MobileWebShellBridgeView
} from './use-mobile-web-shell-bridge'
import { connectionLogStore } from '../transport/persisted-connection-log-store'
const ID = bridgeId(1)
const DIRECTORY = '/caches/mobile-web/deadbeef/generations/a1b2'
@@ -307,19 +301,6 @@ beforeEach(() => {
})
describe('the bridge channel', () => {
it('is closed until the session is ready and opens with it', async () => {
const mounted = await mount({ kind: 'checking' })
expect(mounted.probe.view?.bridgeEnabled).toBe(false)
await mounted.deliver(clientFrame({ type: 'ready' }))
expect(mounted.posted).toEqual([])
await mounted.update(readyState('session-one'))
expect(mounted.probe.view?.bridgeEnabled).toBe(true)
await mounted.deliver(clientFrame({ type: 'ready' }))
expect(mounted.frames('session-one')).toEqual([
expect.objectContaining({ type: 'init', sessionId: 'session-one', buildId: 'build-a' })
])
})
it('does not rebuild the host for a route object the caller built again', async () => {
const mounted = await mount(readyState('session-one'))
await mounted.deliver(clientFrame({ type: 'ready' }))
@@ -354,24 +335,6 @@ describe('the bridge channel', () => {
})
expect(mounted.faults).toEqual([])
})
it('logs a frame it dropped for want of a host once per session, naming what is missing', async () => {
doubles.client = null
const dropped = () =>
connectionLogStore
.get('host-1')
.filter((entry) => entry.message === 'Web shell: page frame with no bridge host')
const before = dropped().length
const mounted = await mount(readyState('session-one'))
await mounted.deliver(clientFrame({ type: 'ready' }))
await mounted.deliver(clientFrame({ type: 'ready' }))
expect(dropped().slice(before)).toEqual([
expect.objectContaining({ detail: 'client=null snapshot=ok' })
])
await mounted.update(readyState('session-two'))
await mounted.deliver(clientFrame({ type: 'ready' }))
expect(dropped().slice(before)).toHaveLength(2)
})
})
describe('teardown', () => {
@@ -389,15 +352,6 @@ describe('teardown', () => {
expect(mounted.frames('session-two')).toEqual([])
})
it(`routes the next session's frames to the next host`, async () => {
const mounted = await mount(readyState('session-one'))
await mounted.update(readyState('session-two'))
await mounted.deliver(clientFrame({ type: 'ready' }))
expect(mounted.frames('session-two')).toEqual([
expect.objectContaining({ type: 'init', sessionId: 'session-two' })
])
})
it('disposes when the session leaves ready, and answers nothing after', async () => {
const mounted = await mount(readyState('session-one'))
await mounted.deliver(clientFrame({ type: 'ready' }))
@@ -410,59 +364,7 @@ describe('teardown', () => {
expect(fakeClient().requests).toEqual([])
})
it('carries the dropped-frame total from the host to the screen', async () => {
const mounted = await mount(readyState('session-one'))
await mounted.deliver(clientFrame({ type: 'ready' }))
await mounted.deliver(
clientFrame({
type: 'subscribe',
id: ID,
method: 'browser.screencast',
params: {},
wantsBinary: true
})
)
const oversized = {
opcode: 1 as const,
seq: 1,
format: 'jpeg' as const,
metadata: {},
image: new Uint8Array(500_000)
}
await act(async () => {
fakeClient().streams[0]?.emitBinary?.(oversized)
fakeClient().streams[0]?.emitBinary?.({ ...oversized, seq: 2 })
})
expect(mounted.probe.droppedBinaryFrames).toEqual([0, 1, 2])
expect(fakeClient().streams[0]?.unsubscribes).toBe(0)
})
// Reset drop counts with host ownership so the next host’s first drop cannot look like recovered frames.
it('resets the dropped-frame total when the host is rebuilt', async () => {
const mounted = await mount(readyState('session-one'))
await mounted.deliver(clientFrame({ type: 'ready' }))
await mounted.deliver(
clientFrame({
type: 'subscribe',
id: ID,
method: 'browser.screencast',
params: {},
wantsBinary: true
})
)
await act(async () => {
fakeClient().streams[0]?.emitBinary?.({
opcode: 1 as const,
seq: 1,
format: 'jpeg' as const,
metadata: {},
image: new Uint8Array(500_000)
})
})
expect(mounted.probe.droppedBinaryFrames).toEqual([0, 1])
await mounted.update(readyState('session-two'))
expect(mounted.probe.droppedBinaryFrames).toEqual([0, 1, 0])
})
it('disposes on unmount and settles what was in flight as delivery-unknown', async () => {
const mounted = await mount(readyState('session-one'))
@@ -490,24 +392,6 @@ describe('teardown', () => {
})
})
describe('diagnostics', () => {
it('names the notification it refused and why, rather than blaming the view', async () => {
const mounted = await mount(readyState('session-one'))
await mounted.deliver(
clientFrame({
type: 'notify',
name: BRIDGE_FAULT_GRANT,
error: { category: 'Error', message: 'too early', isRpcDeliveryUnknown: false }
})
)
expect(mounted.faults).toEqual([])
expect(warned).toHaveBeenCalledWith(expect.stringContaining('refused a page notification'), {
name: BRIDGE_FAULT_GRANT,
why: 'before-ready'
})
})
})
describe('client changes', () => {
// Client replacement preserves the live document/session; retain its Back state so an open sheet cannot lose the next press.
it('keeps delivering Back to an open sheet after the host is rebuilt under it', async () => {
@@ -590,107 +474,6 @@ function newProbe(): Probe {
}
}
describe('the props one render passed', () => {
// Verify callback freshness without host rebuild: pending requests stay open and drop totals announce once.
it('routes each of them into the latest render, without rebuilding the host', async () => {
const posted: PostedFrame[] = []
const first = newProbe()
const second = newProbe()
const firstFaults: BridgeErrorCapture[] = []
const secondFaults: BridgeErrorCapture[] = []
const firstReadies: string[] = []
const secondReadies: string[] = []
const render = (probe: Probe, faults: BridgeErrorCapture[], readies: string[]): ReactElement =>
createElement(Harness, { session: readyState('session-one'), posted, probe, faults, readies })
const rendered: { tree: ReactTestRenderer | null } = { tree: null }
await act(async () => {
rendered.tree = createTracked(render(first, firstFaults, firstReadies))
})
const deliver = async (probe: Probe, json: string): Promise<void> => {
await act(async () => {
probe.view?.onBridgeMessage({ nativeEvent: { json } })
})
}
await deliver(first, clientFrame({ type: 'ready' }))
await deliver(first, clientFrame({ type: 'request', id: ID, method: 'status.get' }))
expect(fakeClient().requests.map((request) => request.method)).toEqual(['status.get'])
await act(async () => {
rendered.tree?.update(render(second, secondFaults, secondReadies))
})
for (const json of [
clientFrame({ type: 'notify', name: 'navigate', href: '/h/host-1/session/wt-2' }),
clientFrame({ type: 'notify', name: 'externalLink', url: 'https://example.com/y' }),
clientFrame({ type: 'notify', name: BRIDGE_HAPTICS_NOTIFY, kind: 'selection' }),
clientFrame({ type: 'notify', name: BRIDGE_NAVIGATE_BACK_NOTIFY }),
clientFrame({ type: 'notify', name: 'storage', key: 'orca:pins:host-1', value: '["wt-2"]' }),
clientFrame({
type: 'notify',
name: BRIDGE_FAULT_GRANT,
error: { category: 'Error', message: 'the route threw', isRpcDeliveryUnknown: false }
}),
clientFrame({ type: 'ready' })
]) {
await deliver(second, json)
}
expect({
navigations: first.navigations,
externalLinks: first.externalLinks,
haptics: first.haptics,
backPops: first.backPops,
storageWrites: first.storageWrites,
faults: firstFaults,
readies: firstReadies
}).toEqual({
navigations: [],
externalLinks: [],
haptics: [],
backPops: 0,
storageWrites: [],
faults: [],
readies: ['session-one']
})
expect({
navigations: second.navigations,
externalLinks: second.externalLinks,
haptics: second.haptics,
backPops: second.backPops,
storageWrites: second.storageWrites,
faults: secondFaults,
readies: secondReadies
}).toEqual({
navigations: ['/h/host-1/session/wt-2'],
externalLinks: ['https://example.com/y'],
haptics: ['selection'],
backPops: 1,
storageWrites: [{ key: 'orca:pins:host-1', value: '["wt-2"]' }],
faults: [{ category: 'Error', message: 'the route threw', isRpcDeliveryUnknown: false }],
readies: ['session-one']
})
const answered = posted.map((frame) => {
const read = readBridgeHostMessage(frame.json)
if (!read.ok) {
throw new Error(`the page would refuse this frame: ${read.refusal}`)
}
return read.message.type
})
expect(answered.filter((type) => type === 'error')).toEqual([])
expect(first.droppedBinaryFrames).toEqual([0])
expect(second.droppedBinaryFrames).toEqual([])
fakeClient().requests[0]?.resolve(rpcSuccess('wire-1', 'ok'))
await flushBridge()
const replied = posted.map((frame) => {
const read = readBridgeHostMessage(frame.json)
if (!read.ok) {
throw new Error(`the page would refuse this frame: ${read.refusal}`)
}
return read.message
})
expect(replied.filter((frame) => frame.type === 'reply')).toEqual([
{ v: 1, type: 'reply', id: ID, payload: rpcSuccess('wire-1', 'ok') }
])
})
})
describe('a session that handshook before this host existed', () => {
// Seed rebuilt hosts from reducer-owned handshake state because client replacement leaves the same document mounted.
it('serves a request from a page that never said `ready` to this host', async () => {
@@ -1,4 +1,3 @@
import { ensureDesktopNotificationChannel } from './desktop-notification-channel'
vi.mock('./desktop-notification-channel', () => ({
ensureDesktopNotificationChannel: vi.fn(async () => {})
}))
@@ -131,24 +130,6 @@ it('does not register with stale consent after the user disables notifications d
)
})
it('waits for notification channel readiness before requesting a token', async () => {
const pending = deferred<void>()
vi.mocked(ensureDesktopNotificationChannel).mockReturnValueOnce(pending.promise)
const connection = client()
attachPushRegistration('host', connection as never)
await vi.waitFor(() => expect(ensureDesktopNotificationChannel).toHaveBeenCalled())
expect(getDevicePushToken).not.toHaveBeenCalled()
expect(connection.sendRequest.mock.calls.map(([method]) => method)).not.toContain(
'notifications.registerPush'
)
pending.resolve()
await vi.waitFor(() =>
expect(connection.sendRequest.mock.calls.map(([method]) => method)).toContain(
'notifications.registerPush'
)
)
})
it('completes disable while native token acquisition remains unresolved, and rejects late tokens', async () => {
vi.useFakeTimers()
storage.set(
@@ -1,346 +0,0 @@
// @vitest-environment happy-dom
import { createElement } from 'react'
import { act, create } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import {
currentSoftKeyboardHeight,
subscribeSoftKeyboard,
useKeyboardOcclusion,
publishShellKeyboardSource
} from './keyboard-occlusion.web'
class FakeVisualViewport extends EventTarget {
height: number
offsetTop = 0
scale: number | undefined = 1
readonly counts = { resize: 0, scroll: 0 }
constructor(height: number) {
super()
this.height = height
}
override addEventListener(type: string, listener: EventListenerOrEventListenerObject): void {
if (type === 'resize' || type === 'scroll') {
this.counts[type] += 1
}
super.addEventListener(type, listener)
}
override removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void {
if (type === 'resize' || type === 'scroll') {
this.counts[type] -= 1
}
super.removeEventListener(type, listener)
}
resizeTo(height: number, offsetTop = 0): void {
this.height = height
this.offsetTop = offsetTop
this.dispatchEvent(new Event('resize'))
}
zoomTo(scale: number): void {
this.scale = scale
this.height = LAYOUT_HEIGHT / scale
this.offsetTop = 0
this.dispatchEvent(new Event('resize'))
}
scrollTo(offsetTop: number): void {
this.offsetTop = offsetTop
this.dispatchEvent(new Event('scroll'))
}
}
const LAYOUT_HEIGHT = 800
let viewport: FakeVisualViewport | null = null
let lift = 0
function Harness(): null {
lift = useKeyboardOcclusion()
return null
}
async function mount(): Promise<ReturnType<typeof create>> {
let tree: ReturnType<typeof create> | null = null
await act(async () => {
tree = create(createElement(Harness))
})
if (tree === null) {
throw new Error('the harness did not mount')
}
return tree
}
beforeEach(() => {
lift = 0
viewport = new FakeVisualViewport(LAYOUT_HEIGHT)
Object.defineProperty(window, 'innerHeight', { value: LAYOUT_HEIGHT, configurable: true })
Object.defineProperty(window, 'visualViewport', { value: viewport, configurable: true })
})
afterEach(() => {
Object.defineProperty(window, 'visualViewport', { value: undefined, configurable: true })
})
describe('the keyboard the browser reports', () => {
it('reads nothing covered while the visual viewport fills the layout one', async () => {
await mount()
expect(lift).toBe(0)
})
it('lifts by the strip the visual viewport stops covering', async () => {
await mount()
await act(async () => viewport?.resizeTo(464))
expect(lift).toBe(336)
})
it('counts an offset visual viewport, which a height alone would read as keyboard', async () => {
// Subtract offsetTop too so a scrolled viewport is not mistaken for extra keyboard height.
await mount()
await act(async () => viewport?.resizeTo(464, 100))
expect(lift).toBe(236)
})
it('follows a scroll that moves the offset without resizing anything', async () => {
await mount()
await act(async () => viewport?.resizeTo(464))
await act(async () => viewport?.scrollTo(50))
expect(lift).toBe(286)
})
it('drops back to nothing when the keyboard closes', async () => {
await mount()
await act(async () => viewport?.resizeTo(464))
await act(async () => viewport?.resizeTo(LAYOUT_HEIGHT))
expect(lift).toBe(0)
})
it('reads the keyboard already up at mount, which sends no event', async () => {
viewport?.resizeTo(464)
await mount()
expect(lift).toBe(336)
})
it('never reports a negative strip, whatever the two viewports disagree about', async () => {
await mount()
await act(async () => viewport?.resizeTo(LAYOUT_HEIGHT + 120))
expect(lift).toBe(0)
})
it('reads a pinch zoom as no keyboard, because geometry alone cannot tell them apart', async () => {
await mount()
await act(async () => viewport?.zoomTo(2))
expect(lift).toBe(0)
})
it('goes back to measuring once the zoom is released', async () => {
await mount()
await act(async () => viewport?.zoomTo(2))
await act(async () => viewport?.zoomTo(1))
await act(async () => viewport?.resizeTo(464))
expect(lift).toBe(336)
})
it('answers 0 for a keyboard raised while the page is zoomed, which is the accepted loss', async () => {
// Geometry cannot separate keyboard from pinch zoom; inputs stay at least 16px to avoid iOS focus zoom.
await mount()
await act(async () => viewport?.zoomTo(2))
await act(async () => viewport?.resizeTo(232))
expect(viewport?.scale).toBe(2)
expect(lift).toBe(0)
})
it('takes a viewport that reports no scale as unzoomed', async () => {
// Missing scale on older WebViews must not suppress every keyboard.
await mount()
await act(async () => {
if (viewport !== null) {
viewport.scale = undefined
viewport.resizeTo(464)
}
})
expect(lift).toBe(336)
})
it('answers 0 when the effect finds no visual viewport to subscribe to', async () => {
Object.defineProperty(window, 'visualViewport', { value: undefined, configurable: true })
await mount()
expect(lift).toBe(0)
})
it('removes both listeners on unmount', async () => {
const tree = await mount()
expect(viewport?.counts).toEqual({ resize: 1, scroll: 1 })
await act(async () => tree.unmount())
expect(viewport?.counts).toEqual({ resize: 0, scroll: 0 })
})
})
describe('the keyboard as events, for a sheet', () => {
it('shows by the uncovered strip and hides once when it closes', () => {
const calls: string[] = []
const unsubscribe = subscribeSoftKeyboard(
(height, duration) => calls.push(`show ${height} ${duration}`),
(duration) => calls.push(`hide ${duration}`)
)
viewport?.resizeTo(464)
viewport?.resizeTo(LAYOUT_HEIGHT)
viewport?.resizeTo(LAYOUT_HEIGHT)
expect(calls).toEqual(['show 336 0', 'hide 0'])
unsubscribe()
expect(viewport?.counts).toEqual({ resize: 0, scroll: 0 })
})
it('hides a keyboard that was already up when it subscribed', async () => {
viewport?.resizeTo(464)
const calls: string[] = []
const unsubscribe = subscribeSoftKeyboard(
(height) => calls.push(`show ${height}`),
(duration) => calls.push(`hide ${duration}`)
)
viewport?.resizeTo(LAYOUT_HEIGHT)
expect(calls).toEqual(['hide 0'])
unsubscribe()
viewport?.resizeTo(464)
await mount()
expect(lift).toBe(336)
await act(async () => viewport?.resizeTo(LAYOUT_HEIGHT))
expect(lift).toBe(0)
})
it('stays silent while the visual viewport covers nothing', () => {
const calls: string[] = []
const unsubscribe = subscribeSoftKeyboard(
() => calls.push('show'),
() => calls.push('hide')
)
viewport?.resizeTo(LAYOUT_HEIGHT)
expect(calls).toEqual([])
unsubscribe()
})
it('reads a keyboard already up, and 0 without a visual viewport', () => {
viewport?.resizeTo(464)
expect(currentSoftKeyboardHeight()).toBe(336)
Object.defineProperty(window, 'visualViewport', { value: undefined, configurable: true })
expect(currentSoftKeyboardHeight()).toBe(0)
expect(() =>
subscribeSoftKeyboard(
() => {},
() => {}
)()
).not.toThrow()
})
})
let keyboardHeight = 0
function StateHarness(): null {
keyboardHeight = useKeyboardOcclusion()
return null
}
async function mountState(): Promise<ReturnType<typeof create>> {
let tree: ReturnType<typeof create> | null = null
await act(async () => {
tree = create(createElement(StateHarness))
})
if (tree === null) {
throw new Error('the harness did not mount')
}
return tree
}
function createShellKeyboard(initial = 0) {
let height = initial
const listeners = new Set<(height: number) => void>()
return {
source: {
read: () => height,
subscribe: (listener: (height: number) => void) => {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
}
},
move: (next: number) => {
height = next
for (const listener of listeners) {
listener(next)
}
},
listenerCount: () => listeners.size
}
}
describe('the state a native screen reads, from the browser outside the shell', () => {
it('is open exactly while something is covered', async () => {
const tree = await mountState()
expect(keyboardHeight).toBe(0)
await act(async () => viewport?.resizeTo(464))
expect(keyboardHeight).toBe(336)
await act(async () => viewport?.resizeTo(LAYOUT_HEIGHT))
expect(keyboardHeight).toBe(0)
await act(async () => tree.unmount())
})
})
// Shell WebViews zero IME insets, so visualViewport cannot measure the keyboard; use bridge heights.
describe('the keyboard the shell says covers the page', () => {
afterEach(() => {
publishShellKeyboardSource(null)
})
it('answers the height the shell sent, and ignores the visual viewport', async () => {
const shell = createShellKeyboard()
publishShellKeyboardSource(shell.source)
const tree = await mountState()
const lifted = await mount()
// Pixel_API_37: the suggestion strip grows IME height from 312 to 346.
for (const height of [312, 346]) {
await act(async () => shell.move(height))
expect(keyboardHeight).toBe(height)
expect(lift).toBe(height)
}
await act(async () => viewport?.resizeTo(464))
expect(keyboardHeight).toBe(346)
await act(async () => shell.move(0))
expect(keyboardHeight).toBe(0)
expect(lift).toBe(0)
await act(async () => {
tree.unmount()
lifted.unmount()
})
expect(shell.listenerCount()).toBe(0)
})
it('reads a keyboard already up at mount, which the shell sent in the first init', async () => {
publishShellKeyboardSource(createShellKeyboard(312).source)
expect(currentSoftKeyboardHeight()).toBe(312)
const tree = await mountState()
expect(keyboardHeight).toBe(312)
await act(async () => tree.unmount())
})
it('hands a sheet each height as a show and the close as one hide', () => {
const shell = createShellKeyboard()
publishShellKeyboardSource(shell.source)
const calls: string[] = []
const unsubscribe = subscribeSoftKeyboard(
(height, duration) => calls.push(`show ${height} ${duration}`),
(duration) => calls.push(`hide ${duration}`)
)
viewport?.resizeTo(464)
shell.move(312)
shell.move(346)
shell.move(0)
shell.move(0)
expect(calls).toEqual(['show 312 0', 'show 346 0', 'hide 0'])
unsubscribe()
expect(shell.listenerCount()).toBe(0)
expect(viewport?.counts).toEqual({ resize: 0, scroll: 0 })
})
})
@@ -1,78 +0,0 @@
// @vitest-environment happy-dom
import { act, useRef } from 'react'
import { createRoot } from 'react-dom/client'
import { TextInput } from 'react-native'
import type * as ReactNative from 'react-native'
import { expect, it, vi } from 'vitest'
import { useTextInputSelectionReveal } from './text-input-selection-reveal.web'
vi.mock('react-native', () => vi.importActual<typeof ReactNative>('react-native-web'))
it('reveals the current caret after the field is capped and preserves later manual scrolling', async () => {
const resized: (() => void)[] = []
class LayoutObserver implements ResizeObserver {
constructor(callback: ResizeObserverCallback) {
resized.push(() => callback([], this))
}
observe() {}
unobserve() {}
disconnect() {}
}
vi.stubGlobal('ResizeObserver', LayoutObserver)
let height = 60
let caretTop = 120
vi.spyOn(HTMLTextAreaElement.prototype, 'clientWidth', 'get').mockReturnValue(300)
vi.spyOn(HTMLTextAreaElement.prototype, 'clientHeight', 'get').mockImplementation(() => height)
vi.spyOn(HTMLSpanElement.prototype, 'getClientRects').mockImplementation(() => {
const rect = new DOMRect(0, caretTop, 1, 20)
return {
0: rect,
length: 1,
item: () => rect,
[Symbol.iterator]: function* (): Generator<DOMRect, undefined, unknown> {
yield rect
}
}
})
function Editor() {
const input = useRef<TextInput>(null)
useTextInputSelectionReveal(input)
return (
<TextInput ref={input} multiline defaultValue={'one\ntwo\nthree\nfour\nfive\nsix\nseven'} />
)
}
const container = document.createElement('div')
document.body.append(container)
const root = createRoot(container)
const paint = () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
try {
await act(async () => root.render(<Editor />))
const field = container.querySelector('textarea')!
field.focus()
field.setSelectionRange(field.value.length, field.value.length)
await act(async () => {
height = 40
resized.forEach((resize) => resize())
await paint()
})
expect(field.scrollTop).toBe(100)
await act(async () => {
caretTop = 40
field.setSelectionRange(4, 4)
field.dispatchEvent(new Event('select'))
await paint()
})
expect(field.scrollTop).toBe(40)
expect(field.selectionStart).toBe(4)
field.scrollTop = 65
field.dispatchEvent(new Event('scroll'))
await act(paint)
expect(field.scrollTop).toBe(65)
expect(document.activeElement).toBe(field)
} finally {
await act(async () => root.unmount())
container.remove()
vi.restoreAllMocks()
vi.unstubAllGlobals()
}
})
@@ -1,39 +0,0 @@
import { afterEach, beforeEach, expect, it, vi } from 'vitest'
import { LogicalClientCutoverError } from '../transport/stable-logical-rpc-client'
import { createOrcaQueryClient } from './orca-query-client'
beforeEach(() => {
vi.useFakeTimers()
})
afterEach(() => {
vi.useRealTimers()
})
it('retries a read cut by a connection migration once and lands its data', async () => {
const queryClient = createOrcaQueryClient()
const queryFn = vi
.fn<() => Promise<string>>()
.mockRejectedValueOnce(new LogicalClientCutoverError())
.mockResolvedValueOnce('rows')
const read = queryClient.query({ queryKey: ['orca', 'host-1', 'test.read'], queryFn })
await vi.advanceTimersByTimeAsync(250)
await expect(read).resolves.toBe('rows')
expect(queryFn).toHaveBeenCalledTimes(2)
})
it('leaves a read refused while disconnected to the connected edge', async () => {
const queryClient = createOrcaQueryClient()
const queryFn = vi
.fn<() => Promise<string>>()
.mockRejectedValue(new Error('Not connected: test.read'))
const read = queryClient.query({ queryKey: ['orca', 'host-1', 'test.read'], queryFn })
const settled = expect(read).rejects.toThrow('Not connected: test.read')
await vi.advanceTimersByTimeAsync(5_000)
await settled
expect(queryFn).toHaveBeenCalledTimes(1)
})