Skip to content

armgit / orca

Public Imported from GitHub
0

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.

6.6 KB
Raw Blame
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)
  })
})