mirror of
https://github.com/stablyai/orca.git
synced 2026-11-17 03:15:01 +00:00
574 lines
19 KiB
TypeScript
574 lines
19 KiB
TypeScript
import { createElement, Suspense, type ReactElement } from 'react'
|
||
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||
|
||
import type { RpcClient } from '../transport/rpc-client'
|
||
import type { RpcResponse } from '../transport/types'
|
||
|
||
const asyncStorage = vi.hoisted(() => ({
|
||
getItem: vi.fn().mockResolvedValue(null),
|
||
setItem: vi.fn().mockResolvedValue(undefined),
|
||
removeItem: vi.fn().mockResolvedValue(undefined)
|
||
}))
|
||
vi.mock('./DisclosureChevron', () => ({
|
||
DisclosureChevron: ({ children }: { children: unknown }) => children
|
||
}))
|
||
vi.mock('@react-native-async-storage/async-storage', () => ({ default: asyncStorage }))
|
||
vi.mock('react-native', () => ({
|
||
ActivityIndicator: 'ActivityIndicator',
|
||
AppState: { currentState: 'active' },
|
||
FlatList: 'FlatList',
|
||
Image: 'Image',
|
||
Keyboard: { dismiss: vi.fn() },
|
||
Linking: { openURL: vi.fn() },
|
||
Modal: 'Modal',
|
||
ScrollView: 'ScrollView',
|
||
Platform: { OS: 'ios', select: (options: { ios?: unknown }) => options.ios },
|
||
Pressable: 'Pressable',
|
||
StyleSheet: { create: <T,>(styles: T) => styles },
|
||
Switch: 'Switch',
|
||
Text: 'Text',
|
||
TextInput: 'TextInput',
|
||
View: 'View'
|
||
}))
|
||
// Every icon in the drawer tree renders as a host element named after itself.
|
||
vi.mock(
|
||
'lucide-react-native',
|
||
() =>
|
||
new Proxy(
|
||
{},
|
||
{
|
||
get: (_target, name) => (typeof name === 'string' ? name : undefined),
|
||
has: () => true
|
||
}
|
||
)
|
||
)
|
||
vi.mock('./bottom-drawer/BottomDrawer', () => ({ BottomDrawer: 'BottomDrawer' }))
|
||
vi.mock('./bottom-drawer/bottom-drawer-modal-host', () => ({
|
||
BottomDrawerModalHost: 'BottomDrawerModalHost'
|
||
}))
|
||
vi.mock('./PickerListDrawer', () => ({ PickerListDrawer: 'PickerListDrawer' }))
|
||
vi.mock('./AutoHeight', () => ({ AutoHeight: 'AutoHeight' }))
|
||
vi.mock('./MobileSwitch', () => ({ MobileSwitch: 'MobileSwitch' }))
|
||
vi.mock('./MobileAgentIcon', () => ({ MobileAgentIcon: 'MobileAgentIcon' }))
|
||
vi.mock('./TaskProviderLogo', () => ({ TaskProviderLogo: 'TaskProviderLogo' }))
|
||
|
||
import { setCachedRepos } from '../cache/repo-cache'
|
||
import { recordHostDescriptor } from '../transport/host-descriptor-store'
|
||
import { FakeSession } from '../transport/mobile-endpoint-supervisor-test-fakes'
|
||
import {
|
||
getLocalExecutionHostLabel,
|
||
type ExecutionHostId
|
||
} from '../../../src/shared/execution-host'
|
||
|
||
import { NewWorktreeModal } from './NewWorktreeModal'
|
||
|
||
import { findAllByHostType } from '../test-support/react-test-renderer-host-nodes'
|
||
|
||
const LOCAL_HOST_LABEL = getLocalExecutionHostLabel('darwin')
|
||
|
||
const repos = [
|
||
{
|
||
id: 'repo-1',
|
||
displayName: 'orca',
|
||
path: '/src/orca',
|
||
kind: 'git',
|
||
upstream: { owner: 'stablyai', repo: 'orca' }
|
||
}
|
||
]
|
||
|
||
function pickerItems(
|
||
renderer: ReactTestRenderer,
|
||
title: string
|
||
): { label: string; detail: string }[] {
|
||
const pickers = findAllByHostType(renderer.root, 'PickerListDrawer')
|
||
const picker = pickers.find((node) => node.props.title === title)
|
||
return picker?.props.items ?? []
|
||
}
|
||
|
||
function sourceInputs(renderer: ReactTestRenderer) {
|
||
return findAllByHostType(renderer.root, 'TextInput').filter(
|
||
(node) => node.props.placeholder === 'Type a name or search a source'
|
||
)
|
||
}
|
||
|
||
function requestsOnly(sendRequest: RpcClient['sendRequest']): RpcClient {
|
||
const client = new FakeSession('connected')
|
||
client.sendRequest.mockImplementation(sendRequest)
|
||
return client
|
||
}
|
||
|
||
function replied(result: unknown): Promise<RpcResponse> {
|
||
return Promise.resolve({ id: 'reply', ok: true, result })
|
||
}
|
||
|
||
function runTargetPicker(renderer: ReactTestRenderer) {
|
||
return findAllByHostType(renderer.root, 'PickerListDrawer').find(
|
||
(node) => node.props.title === 'Run on'
|
||
)!
|
||
}
|
||
|
||
async function flushUpdates(): Promise<void> {
|
||
await act(async () => {
|
||
await Promise.resolve()
|
||
await Promise.resolve()
|
||
await Promise.resolve()
|
||
})
|
||
}
|
||
|
||
describe('NewWorktreeModal project targets', () => {
|
||
let renderer: ReactTestRenderer
|
||
|
||
beforeEach(() => {
|
||
setCachedRepos('host-1', repos)
|
||
})
|
||
|
||
afterEach(() => {
|
||
act(() => renderer?.unmount())
|
||
})
|
||
|
||
it('keeps the cached repos when the in-flight repo.list rejects on a dropped connection', async () => {
|
||
const sendRequest = vi.fn().mockImplementation((method: string) => {
|
||
if (method === 'repo.list') {
|
||
return Promise.reject(new Error('connection closed'))
|
||
}
|
||
if (method === 'status.get') {
|
||
return Promise.resolve({ ok: true, result: { hostPlatform: 'darwin' } })
|
||
}
|
||
return new Promise(() => {})
|
||
})
|
||
const client = requestsOnly(sendRequest)
|
||
|
||
await act(async () => {
|
||
renderer = create(
|
||
createElement(NewWorktreeModal, {
|
||
visible: true,
|
||
client,
|
||
hostId: 'host-1',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
})
|
||
)
|
||
await Promise.resolve()
|
||
})
|
||
await act(async () => {
|
||
await Promise.resolve()
|
||
})
|
||
|
||
expect(sendRequest).toHaveBeenCalledWith('repo.list')
|
||
expect(pickerItems(renderer, 'Project')).toEqual([
|
||
expect.objectContaining({ label: 'orca', detail: 'stablyai/orca' })
|
||
])
|
||
expect(pickerItems(renderer, 'Run on')).toEqual([
|
||
expect.objectContaining({ label: LOCAL_HOST_LABEL, detail: '/src/orca' })
|
||
])
|
||
})
|
||
|
||
it('loads SSH state before detecting agents on the selected remote target', async () => {
|
||
const remoteRepo = {
|
||
id: 'repo-remote',
|
||
displayName: 'orca',
|
||
path: '/home/dev/orca',
|
||
connectionId: 'build-server',
|
||
kind: 'git',
|
||
upstream: { owner: 'stablyai', repo: 'orca' }
|
||
}
|
||
setCachedRepos('host-ssh', [remoteRepo])
|
||
let resolveSshState: ((reply: unknown) => void) | undefined
|
||
const sshState = new Promise((resolve) => {
|
||
resolveSshState = resolve
|
||
})
|
||
const sendRequest = vi.fn().mockImplementation((method: string) => {
|
||
if (method === 'repo.list') {
|
||
return Promise.resolve({ ok: true, result: { repos: [remoteRepo] } })
|
||
}
|
||
if (method === 'ssh.getState') {
|
||
return sshState
|
||
}
|
||
if (method === 'preflight.detectRemoteAgents') {
|
||
return Promise.resolve({ ok: true, result: ['codex'] })
|
||
}
|
||
if (method === 'settings.get') {
|
||
return Promise.resolve({ ok: true, result: { settings: { defaultTuiAgent: 'codex' } } })
|
||
}
|
||
if (method === 'ui.get') {
|
||
return Promise.resolve({ ok: true, result: { ui: {} } })
|
||
}
|
||
if (method === 'preflight.check') {
|
||
return Promise.resolve({ ok: true, result: {} })
|
||
}
|
||
if (method === 'linear.status') {
|
||
return Promise.resolve({ ok: true, result: {} })
|
||
}
|
||
if (method === 'status.get') {
|
||
return Promise.resolve({ ok: true, result: { hostPlatform: 'linux' } })
|
||
}
|
||
if (method === 'repo.hooks') {
|
||
return Promise.resolve({ ok: true, result: { hooks: null, source: null } })
|
||
}
|
||
return Promise.resolve({ ok: true, result: {} })
|
||
})
|
||
const client = requestsOnly(sendRequest)
|
||
|
||
await act(async () => {
|
||
renderer = create(
|
||
createElement(NewWorktreeModal, {
|
||
visible: true,
|
||
client,
|
||
hostId: 'host-ssh',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
})
|
||
)
|
||
})
|
||
await flushUpdates()
|
||
|
||
expect(sendRequest).toHaveBeenCalledWith('ssh.getState', { targetId: 'build-server' })
|
||
expect(
|
||
sendRequest.mock.calls.some(([method]) => method === 'preflight.detectRemoteAgents')
|
||
).toBe(false)
|
||
await act(async () => {
|
||
resolveSshState?.({
|
||
ok: true,
|
||
result: {
|
||
state: {
|
||
targetId: 'build-server',
|
||
status: 'connected',
|
||
error: null,
|
||
reconnectAttempt: 0
|
||
}
|
||
}
|
||
})
|
||
})
|
||
await flushUpdates()
|
||
expect(sendRequest).toHaveBeenCalledWith('preflight.detectRemoteAgents', {
|
||
connectionId: 'build-server'
|
||
})
|
||
})
|
||
|
||
it("creates a server repo's workspace on that server and names it for the route", async () => {
|
||
const serverRepo = { ...repos[0]!, id: 'server-repo', path: '/srv/orca' }
|
||
const serverSshRepo = { ...serverRepo, id: 'server-ssh', connectionId: 'its-own-ssh' }
|
||
const reply = (method: string, listed: unknown[], hostPlatform: string) => {
|
||
if (method === 'repo.list') {
|
||
return replied({ repos: listed })
|
||
}
|
||
if (method === 'status.get') {
|
||
return replied({ hostPlatform })
|
||
}
|
||
if (method === 'worktree.create') {
|
||
return replied({
|
||
worktree: { id: 'srv-wt', displayName: 'srv-wt', path: '/srv/orca-wt' }
|
||
})
|
||
}
|
||
if (method === 'settings.get') {
|
||
return replied({ settings: {} })
|
||
}
|
||
return replied({})
|
||
}
|
||
const desktop = vi.fn((method: string) => reply(method, repos, 'darwin'))
|
||
const server = vi.fn((method: string) => reply(method, [serverRepo, serverSshRepo], 'linux'))
|
||
const onCreated = vi.fn()
|
||
recordHostDescriptor('host-1', { machineName: null, platform: 'darwin' })
|
||
|
||
await act(async () => {
|
||
renderer = create(
|
||
createElement(NewWorktreeModal, {
|
||
visible: true,
|
||
client: requestsOnly(desktop),
|
||
serverClients: new Map<ExecutionHostId, RpcClient>([
|
||
['runtime:env-1', requestsOnly(server)]
|
||
]),
|
||
hostId: 'host-1',
|
||
hostLabelById: new Map<ExecutionHostId, string>([['runtime:env-1', 'scratch-server']]),
|
||
onCreated,
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
})
|
||
)
|
||
})
|
||
await flushUpdates()
|
||
|
||
const runTargets = pickerItems(renderer, 'Run on')
|
||
expect(runTargets.map((item) => [item.label, item.detail])).toEqual([
|
||
[LOCAL_HOST_LABEL, '/src/orca'],
|
||
['scratch-server', '/srv/orca']
|
||
])
|
||
const serverTarget = runTargetPicker(renderer)
|
||
const iconOf = (item: unknown) => {
|
||
let icon: ReactTestRenderer | undefined
|
||
act(() => {
|
||
icon = create(serverTarget.props.renderIcon(item))
|
||
})
|
||
return icon?.toJSON()
|
||
}
|
||
expect(serverTarget.props.items.map(iconOf)).toMatchObject([
|
||
{ type: 'Monitor' },
|
||
{ type: 'Server' }
|
||
])
|
||
await act(async () => serverTarget.props.onSelect(serverTarget.props.items[1]))
|
||
await flushUpdates()
|
||
// The Run on field shows the picked server's glyph, as its row does.
|
||
expect(findAllByHostType(renderer.root, 'Server')).toHaveLength(1)
|
||
expect(pickerItems(renderer, 'Run on')[0]?.label).toBe(LOCAL_HOST_LABEL)
|
||
act(() => sourceInputs(renderer)[0]!.props.onChangeText('srv-wt'))
|
||
const form = renderer.root.find((node) => typeof node.props.onCreate === 'function')
|
||
await act(async () => form.props.onCreate())
|
||
await flushUpdates()
|
||
|
||
expect(server).toHaveBeenCalledWith(
|
||
'worktree.create',
|
||
expect.objectContaining({ repo: 'id:server-repo' }),
|
||
expect.anything()
|
||
)
|
||
expect(desktop).not.toHaveBeenCalledWith(
|
||
'worktree.create',
|
||
expect.anything(),
|
||
expect.anything()
|
||
)
|
||
expect(onCreated).toHaveBeenCalledWith('srv-wt', expect.any(String), undefined, 'runtime:env-1')
|
||
})
|
||
|
||
it("lists the desktop's repos at once while a server has not answered", async () => {
|
||
const desktop = vi.fn((method: string) =>
|
||
method === 'repo.list' ? replied({ repos }) : new Promise<never>(() => {})
|
||
)
|
||
const hungServer = vi.fn(() => new Promise<never>(() => {}))
|
||
|
||
await act(async () => {
|
||
renderer = create(
|
||
createElement(NewWorktreeModal, {
|
||
visible: true,
|
||
client: requestsOnly(desktop),
|
||
serverClients: new Map<ExecutionHostId, RpcClient>([
|
||
['runtime:env-1', requestsOnly(hungServer)]
|
||
]),
|
||
hostId: 'host-cold',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
})
|
||
)
|
||
})
|
||
await flushUpdates()
|
||
|
||
expect(hungServer).toHaveBeenCalledWith('repo.list')
|
||
expect(pickerItems(renderer, 'Run on').map((item) => item.detail)).toEqual(['/src/orca'])
|
||
})
|
||
|
||
it('keeps a server repo picked when the desktop lists a repo with the same id', async () => {
|
||
const serverRepo = { ...repos[0]!, path: '/srv/orca' }
|
||
const listing = (listed: unknown[]) =>
|
||
vi.fn((method: string) =>
|
||
method === 'repo.list' ? replied({ repos: listed }) : new Promise<never>(() => {})
|
||
)
|
||
|
||
await act(async () => {
|
||
renderer = create(
|
||
createElement(NewWorktreeModal, {
|
||
visible: true,
|
||
client: requestsOnly(listing(repos)),
|
||
serverClients: new Map<ExecutionHostId, RpcClient>([
|
||
['runtime:env-1', requestsOnly(listing([serverRepo]))]
|
||
]),
|
||
hostId: 'host-1',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
})
|
||
)
|
||
})
|
||
await flushUpdates()
|
||
const picker = runTargetPicker(renderer)
|
||
await act(async () => picker.props.onSelect(picker.props.items[1]))
|
||
await flushUpdates()
|
||
|
||
expect(runTargetPicker(renderer).props.selectedId).toBe('runtime:env-1')
|
||
expect(
|
||
renderer.root.find((node) => node.props.runTarget !== undefined).props.runTarget.detail
|
||
).toBe('/srv/orca')
|
||
})
|
||
|
||
it('ignores a stale repo list after the client changes', async () => {
|
||
let resolveOldList: ((value: unknown) => void) | undefined
|
||
const oldList = new Promise((resolve) => {
|
||
resolveOldList = resolve
|
||
})
|
||
const freshRepo = { ...repos[0]!, id: 'repo-fresh', displayName: 'fresh' }
|
||
const oldClient = requestsOnly(
|
||
vi.fn().mockImplementation((method: string) => {
|
||
if (method === 'repo.list') {
|
||
return oldList
|
||
}
|
||
return new Promise(() => {})
|
||
})
|
||
)
|
||
const freshClient = requestsOnly(
|
||
vi.fn().mockImplementation((method: string) => {
|
||
if (method === 'repo.list') {
|
||
return Promise.resolve({ ok: true, result: { repos: [freshRepo] } })
|
||
}
|
||
if (method === 'status.get') {
|
||
return Promise.resolve({ ok: true, result: { hostPlatform: 'darwin' } })
|
||
}
|
||
return new Promise(() => {})
|
||
})
|
||
)
|
||
const modalProps = {
|
||
visible: true,
|
||
hostId: 'host-1',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
}
|
||
|
||
await act(async () => {
|
||
renderer = create(createElement(NewWorktreeModal, { ...modalProps, client: oldClient }))
|
||
})
|
||
const sourceInput = sourceInputs(renderer)[0]!
|
||
act(() => sourceInput.props.onChangeText('stale-client-name'))
|
||
expect(sourceInput.props.value).toBe('stale-client-name')
|
||
await act(async () => {
|
||
renderer.update(createElement(NewWorktreeModal, { ...modalProps, client: freshClient }))
|
||
await Promise.resolve()
|
||
})
|
||
// A reconnect changes the client without restarting this host's form session.
|
||
expect(sourceInputs(renderer).map((input) => input.props.value)).toEqual([
|
||
'stale-client-name',
|
||
'stale-client-name'
|
||
])
|
||
resolveOldList?.({ ok: true, result: { repos } })
|
||
await flushUpdates()
|
||
|
||
expect(pickerItems(renderer, 'Project')).toEqual([expect.objectContaining({ label: 'fresh' })])
|
||
})
|
||
|
||
// Blurred react-native-screens freezes by suspending/react-freeze; discarded render mutations otherwise outlive React’s work.
|
||
function suspendableTree(frozen: () => boolean, child: ReactElement) {
|
||
const never = new Promise<void>(() => {})
|
||
const Freezer = () => {
|
||
if (frozen()) {
|
||
throw never
|
||
}
|
||
return null
|
||
}
|
||
// The modal renders first, so its render completes before the freeze throws.
|
||
return createElement(Suspense, { fallback: null }, child, createElement(Freezer, null))
|
||
}
|
||
|
||
it('keeps the form when a host switch renders but never commits', async () => {
|
||
setCachedRepos('host-2', repos)
|
||
const client = requestsOnly(vi.fn().mockImplementation(() => new Promise(() => {})))
|
||
const modalProps = {
|
||
visible: true,
|
||
client,
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
}
|
||
let frozen = false
|
||
const tree = (hostId: string) =>
|
||
suspendableTree(() => frozen, createElement(NewWorktreeModal, { ...modalProps, hostId }))
|
||
|
||
await act(async () => {
|
||
renderer = create(tree('host-1'))
|
||
})
|
||
act(() => sourceInputs(renderer)[0]!.props.onChangeText('keep-me'))
|
||
|
||
frozen = true
|
||
await act(async () => {
|
||
renderer.update(tree('host-2'))
|
||
})
|
||
frozen = false
|
||
await act(async () => {
|
||
renderer.update(tree('host-1'))
|
||
})
|
||
|
||
// host-2 never committed, so host-1's session was never superseded.
|
||
expect(sourceInputs(renderer).map((input) => input.props.value)).toEqual(['keep-me', 'keep-me'])
|
||
})
|
||
|
||
it('keeps the form when a close renders but never commits', async () => {
|
||
const client = requestsOnly(vi.fn().mockImplementation(() => new Promise(() => {})))
|
||
const modalProps = {
|
||
client,
|
||
hostId: 'host-1',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
}
|
||
let frozen = false
|
||
const tree = (visible: boolean) =>
|
||
suspendableTree(() => frozen, createElement(NewWorktreeModal, { ...modalProps, visible }))
|
||
|
||
await act(async () => {
|
||
renderer = create(tree(true))
|
||
})
|
||
act(() => sourceInputs(renderer)[0]!.props.onChangeText('keep-me-too'))
|
||
|
||
frozen = true
|
||
await act(async () => {
|
||
renderer.update(tree(false))
|
||
})
|
||
frozen = false
|
||
await act(async () => {
|
||
renderer.update(tree(true))
|
||
})
|
||
|
||
// The drawer never committed a closed state, so this is not a reopening.
|
||
expect(sourceInputs(renderer).map((input) => input.props.value)).toEqual([
|
||
'keep-me-too',
|
||
'keep-me-too'
|
||
])
|
||
})
|
||
|
||
it('starts a fresh form session when the modal switches hosts', async () => {
|
||
setCachedRepos('host-2', repos)
|
||
const client = requestsOnly(vi.fn().mockImplementation(() => new Promise(() => {})))
|
||
const modalProps = {
|
||
visible: true,
|
||
client,
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
}
|
||
|
||
await act(async () => {
|
||
renderer = create(createElement(NewWorktreeModal, { ...modalProps, hostId: 'host-1' }))
|
||
})
|
||
act(() => sourceInputs(renderer)[0]!.props.onChangeText('host-one-name'))
|
||
|
||
await act(async () => {
|
||
renderer.update(createElement(NewWorktreeModal, { ...modalProps, hostId: 'host-2' }))
|
||
})
|
||
|
||
expect(sourceInputs(renderer).map((input) => input.props.value)).toEqual(['', ''])
|
||
})
|
||
|
||
it('starts with fresh form state after closing and reopening', async () => {
|
||
const sendRequest = vi.fn().mockImplementation(() => new Promise(() => {}))
|
||
const client = requestsOnly(sendRequest)
|
||
const modalProps = {
|
||
client,
|
||
hostId: 'host-1',
|
||
onCreated: () => {},
|
||
onClose: () => {},
|
||
openExternalUrl: () => {}
|
||
}
|
||
|
||
await act(async () => {
|
||
renderer = create(createElement(NewWorktreeModal, { ...modalProps, visible: true }))
|
||
})
|
||
const sourceInput = sourceInputs(renderer)[0]!
|
||
act(() => sourceInput.props.onChangeText('previous-workspace'))
|
||
|
||
act(() => renderer.update(createElement(NewWorktreeModal, { ...modalProps, visible: false })))
|
||
act(() => renderer.update(createElement(NewWorktreeModal, { ...modalProps, visible: true })))
|
||
|
||
expect(sourceInputs(renderer).map((input) => input.props.value)).toEqual(['', ''])
|
||
expect(sendRequest.mock.calls.filter(([method]) => method === 'repo.list')).toHaveLength(2)
|
||
})
|
||
})
|