Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { afterEach, describe, expect, it, vi } from 'vitest'
import { CLIPBOARD_IMAGE_MAX_SOURCE_BYTES } from '../../../src/shared/clipboard-image'
vi.mock('expo-image-picker', () => ({
requestMediaLibraryPermissionsAsync: vi.fn(),
launchImageLibraryAsync: vi.fn()
}))
vi.mock('expo-document-picker', () => ({
getDocumentAsync: vi.fn()
}))
vi.mock('expo-file-system', () => ({
File: vi.fn()
}))
import {
ImageLibraryPermissionError,
pickMobileImage,
pickMobileImages,
type PickedMobileImage
} from './mobile-image-source-picker'
const granted = { granted: true } as Awaited<
ReturnType<typeof import('expo-image-picker').requestMediaLibraryPermissionsAsync>
>
const denied = { granted: false } as typeof granted
async function collectImages(
images: AsyncIterable<PickedMobileImage>
): Promise<PickedMobileImage[]> {
const collected: PickedMobileImage[] = []
for await (const image of images) {
collected.push(image)
}
return collected
}
function fileFactory(
bytes: Uint8Array,
options?: { fileSize?: number; handleSize?: number | null; readError?: Error }
) {
const close = vi.fn()
const chunks = [bytes]
const readBytes = vi.fn(() => {
if (options?.readError) {
throw options.readError
}
return chunks.shift() ?? new Uint8Array()
})
const open = vi.fn(() => ({
size: options?.handleSize ?? options?.fileSize ?? bytes.length,
readBytes,
close
}))
const createFile = vi.fn(() => ({ size: options?.fileSize ?? bytes.length, open }))
return { close, createFile, open }
}
describe('pickMobileImage', () => {
afterEach(() => vi.restoreAllMocks())
it('reads a photo URI without relying on React Native fetch', async () => {
const bytes = new Uint8Array([0, 1, 2, 3])
const file = fileFactory(bytes)
const launchLibrary = vi.fn().mockResolvedValue({
canceled: false,
assets: [{ uri: 'file:///x.jpg', fileSize: bytes.length }]
})
const fetchSpy = vi
.spyOn(globalThis, 'fetch')
.mockRejectedValue(new Error('Network request failed'))
const result = await pickMobileImage('library', {
requestLibraryPermission: vi.fn().mockResolvedValue(granted),
launchLibrary,
createFile: file.createFile
})
expect(result).toEqual({
base64: Buffer.from(bytes).toString('base64'),
uri: 'file:///x.jpg'
})
expect(launchLibrary).toHaveBeenCalledWith(expect.objectContaining({ base64: false }))
expect(fetchSpy).not.toHaveBeenCalled()
expect(file.close).toHaveBeenCalledTimes(1)
})
it('returns every selected library photo in order', async () => {
const bytesByUri = new Map([
['file:///a.jpg', new Uint8Array([1])],
['file:///b.jpg', new Uint8Array([2])],
['file:///c.jpg', new Uint8Array([3])]
])
const createFile = vi.fn((uri: string) => {
const bytes = bytesByUri.get(uri)!
let read = false
return {
size: bytes.length,
open: () => ({
size: bytes.length,
readBytes: () => {
if (read) {
return new Uint8Array()
}
read = true
return bytes
},
close: vi.fn()
})
}
})
const launchLibrary = vi.fn().mockResolvedValue({
canceled: false,
assets: [...bytesByUri].map(([uri, bytes]) => ({ uri, fileSize: bytes.length }))
})
const result = await collectImages(
pickMobileImages('library', {
requestLibraryPermission: vi.fn().mockResolvedValue(granted),
launchLibrary,
createFile
})
)
expect(result).toEqual([
{ uri: 'file:///a.jpg', base64: 'AQ==' },
{ uri: 'file:///b.jpg', base64: 'Ag==' },
{ uri: 'file:///c.jpg', base64: 'Aw==' }
])
expect(launchLibrary).toHaveBeenCalledWith(
expect.objectContaining({
allowsMultipleSelection: true,
orderedSelection: true,
selectionLimit: 0
})
)
})
it('throws when photo library permission is denied', async () => {
await expect(
pickMobileImage('library', {
requestLibraryPermission: vi.fn().mockResolvedValue(denied),
launchLibrary: vi.fn()
})
).rejects.toBeInstanceOf(ImageLibraryPermissionError)
})
it('returns null when the library picker is cancelled', async () => {
const result = await pickMobileImage('library', {
requestLibraryPermission: vi.fn().mockResolvedValue(granted),
launchLibrary: vi.fn().mockResolvedValue({ canceled: true, assets: null })
})
expect(result).toBeNull()
})
it('reads any picked file into base64 and keeps its name for the files source', async () => {
const bytes = new Uint8Array([1, 2, 3, 4])
const file = fileFactory(bytes)
const launchFiles = vi.fn().mockResolvedValue({
canceled: false,
assets: [
{
uri: 'file:///book.txt',
name: '柴静-看见.txt',
mimeType: 'text/plain',
size: bytes.length
}
]
})
const result = await pickMobileImage('files', {
launchFiles,
createFile: file.createFile
})
expect(launchFiles).toHaveBeenCalledWith(expect.objectContaining({ type: '*/*' }))
expect(result).toEqual({
base64: Buffer.from(bytes).toString('base64'),
uri: 'file:///book.txt',
fileName: '柴静-看见.txt'
})
expect(file.close).toHaveBeenCalledTimes(1)
})
it('returns null when the files picker is cancelled', async () => {
const result = await pickMobileImage('files', {
launchFiles: vi.fn().mockResolvedValue({ canceled: true, assets: null })
})
expect(result).toBeNull()
})
it('rejects an oversized asset before opening it', async () => {
const file = fileFactory(new Uint8Array([1]))
await expect(
pickMobileImage('files', {
launchFiles: vi.fn().mockResolvedValue({
canceled: false,
assets: [{ uri: 'file:///huge.png', size: CLIPBOARD_IMAGE_MAX_SOURCE_BYTES + 1 }]
}),
createFile: file.createFile
})
).rejects.toThrow('Clipboard image is too large')
expect(file.createFile).not.toHaveBeenCalled()
expect(file.open).not.toHaveBeenCalled()
})
it('closes the file handle when reading fails', async () => {
const file = fileFactory(new Uint8Array(), { fileSize: 4, readError: new Error('read failed') })
await expect(
pickMobileImage('files', {
launchFiles: vi.fn().mockResolvedValue({
canceled: false,
assets: [{ uri: 'file:///broken.png', size: 4 }]
}),
createFile: file.createFile
})
).rejects.toThrow('read failed')
expect(file.close).toHaveBeenCalledTimes(1)
})
})