@morscherlab/mint-sdk 1.2.0-beta.12 → 1.2.0-beta.14

package/src/__tests__/components/FilePicker.test.ts

@@ -0,0 +1,328 @@
+import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import FilePicker from '../../components/FilePicker.vue'
+import type { PickerAdapter, PickerNode, PickerSelection } from '../../types/filePicker'
+import { localFilesAdapter } from '../../composables/filePicker/localFiles'
+import { pickerExclusion } from '../../composables/filePicker/validation'
+
+enableAutoUnmount(afterEach)
+afterEach(() => vi.useRealTimers())
+const folder: PickerNode = {
+  kind: 'folder',
+  path: 'opaque:a',
+  name: 'Tissue liver',
+  fileCount: 3,
+  bytes: 60,
+  formats: { raw: 2, txt: 1 },
+}
+const other: PickerNode = { kind: 'folder', path: 'opaque:b', name: 'Tissue kidney' }
+const one: PickerNode = {
+  kind: 'file',
+  path: 'file:one',
+  parentPath: folder.path,
+  name: 'sample-01.raw',
+  bytes: 20,
+  format: 'raw',
+}
+const two: PickerNode = {
+  kind: 'file',
+  path: 'file:two',
+  parentPath: folder.path,
+  name: 'sample-02.raw',
+  bytes: 20,
+  format: 'raw',
+}
+const unsupported: PickerNode = {
+  kind: 'file',
+  path: 'file:notes',
+  parentPath: folder.path,
+  name: 'notes.txt',
+  bytes: 20,
+  format: 'txt',
+}
+function adapter(): PickerAdapter {
+  return {
+    listRoot: vi.fn(async () => [folder, other]),
+    listChildren: vi.fn(async (path) => (path === folder.path ? [one, two, unsupported] : [])),
+    search: vi.fn(async (query) =>
+      [folder, one, two, unsupported].filter((node) =>
+        node.name.toLowerCase().includes(query.toLowerCase()),
+      ),
+    ),
+  }
+}
+async function setup(props: Record<string, unknown> = {}) {
+  const wrapper = mount(FilePicker, {
+    props: {
+      open: true,
+      adapter: adapter(),
+      capabilities: { server: { formats: ['raw'] } },
+      ...props,
+    },
+    global: { stubs: { teleport: true } },
+  })
+  await flushPromises()
+  return wrapper
+}
+function row(wrapper: Awaited<ReturnType<typeof setup>>, path: string) {
+  return wrapper.findAll('[role="treeitem"]').find((item) => item.attributes('data-path') === path)!
+}
+function confirm(wrapper: Awaited<ReturnType<typeof setup>>) {
+  return wrapper.findAll('.mint-picker__actions button').at(-1)!
+}
+async function expand(wrapper: Awaited<ReturnType<typeof setup>>) {
+  await wrapper.get('[aria-label="Expand Tissue liver"]').trigger('click')
+  await flushPromises()
+}
+
+describe('FilePicker', () => {
+  it('selects a folder without navigating, resolves metadata and excludes unsupported files', async () => {
+    const wrapper = await setup()
+    await row(wrapper, folder.path).trigger('click')
+    await flushPromises()
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('true')
+    expect(wrapper.findAll('[role="treeitem"]')).toHaveLength(2)
+    await confirm(wrapper).trigger('click')
+    const result = wrapper.emitted('select')?.[0]?.[0] as Extract<
+      PickerSelection,
+      { source: 'server' }
+    >
+    expect(result.folders).toEqual([folder.path])
+    expect(result.files.map((file) => file.path)).toEqual([one.path, two.path])
+    expect(result.excluded).toEqual([
+      { path: unsupported.path, name: unsupported.name, reason: 'unsupported' },
+    ])
+  })
+
+  it('discloses without selecting and double-clicks to navigate', async () => {
+    const wrapper = await setup()
+    await expand(wrapper)
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('false')
+    expect(wrapper.findAll('[role="treeitem"]')).toHaveLength(5)
+    await row(wrapper, folder.path).trigger('dblclick')
+    await flushPromises()
+    expect(wrapper.findAll('[role="treeitem"]')).toHaveLength(3)
+    expect(wrapper.get('[aria-label="Breadcrumb"]').text()).toContain(folder.name)
+  })
+
+  it('drops an inherited file with Ctrl and restores it with another Ctrl click', async () => {
+    const wrapper = await setup()
+    await row(wrapper, folder.path).trigger('click')
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click', { ctrlKey: true })
+    expect(row(wrapper, one.path).attributes('aria-selected')).toBe('false')
+    expect(row(wrapper, folder.path).text()).toContain('1 / 3')
+    await confirm(wrapper).trigger('click')
+    const result = wrapper.emitted('select')?.[0]?.[0] as Extract<
+      PickerSelection,
+      { source: 'server' }
+    >
+    expect(result.excluded).toContainEqual({ path: one.path, name: one.name, reason: 'deselected' })
+    await row(wrapper, one.path).trigger('click', { metaKey: true })
+    expect(row(wrapper, one.path).attributes('aria-selected')).toBe('true')
+  })
+
+  it('keeps unsupported files inert for click, double-click and keyboard', async () => {
+    const wrapper = await setup({ selectionMode: 'single-file' })
+    await expand(wrapper)
+    const unavailable = row(wrapper, unsupported.path)
+    expect(unavailable.attributes('aria-disabled')).toBe('true')
+    expect(unavailable.attributes('title')).toContain('not supported')
+    await unavailable.trigger('click')
+    await unavailable.trigger('dblclick')
+    await unavailable.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('select')).toBeUndefined()
+    expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+  })
+
+  it('single-file mode replaces selection and folder mode leaves files inert', async () => {
+    const wrapper = await setup({ selectionMode: 'single-file' })
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click')
+    await row(wrapper, two.path).trigger('click', { metaKey: true })
+    await flushPromises()
+    await confirm(wrapper).trigger('click')
+    expect(
+      (wrapper.emitted('select')?.[0]?.[0] as { files: PickerNode[] }).files.map(
+        (file) => file.path,
+      ),
+    ).toEqual([two.path])
+    const folders = await setup({ selectionMode: 'folder' })
+    await expand(folders)
+    await row(folders, one.path).trigger('click')
+    expect(row(folders, one.path).attributes('aria-selected')).toBe('false')
+  })
+
+  it('uses Shift to select the file range, excluding unsupported entries', async () => {
+    const wrapper = await setup({ selectionMode: 'multi-file' })
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click')
+    await row(wrapper, two.path).trigger('click', { shiftKey: true })
+    await flushPromises()
+    await confirm(wrapper).trigger('click')
+    expect((wrapper.emitted('select')?.[0]?.[0] as { files: PickerNode[] }).files).toHaveLength(2)
+  })
+
+  it('preserves selected paths while searching and passes the recursive scope', async () => {
+    vi.useFakeTimers()
+    const data = adapter()
+    const wrapper = await setup({ adapter: data })
+    await row(wrapper, folder.path).trigger('click')
+    await flushPromises()
+    await wrapper.get('[aria-label="Search folders and files"]').setValue('sample')
+    await wrapper.get('.mint-picker__scope').trigger('click')
+    await vi.advanceTimersByTimeAsync(250)
+    expect(data.search).toHaveBeenCalledWith(
+      'sample',
+      { path: '', recursive: true },
+      expect.anything(),
+    )
+    expect(confirm(wrapper).attributes('disabled')).toBeUndefined()
+    await confirm(wrapper).trigger('click')
+    expect((wrapper.emitted('select')?.[0]?.[0] as { folders: string[] }).folders).toEqual([
+      folder.path,
+    ])
+  })
+
+  it('cancel emits no selection and reopening restores the initial confirmed selection', async () => {
+    const initial: PickerSelection = {
+      source: 'server',
+      folders: [folder.path],
+      files: [],
+      excluded: [],
+    }
+    const wrapper = await setup({ initialSelection: initial })
+    await row(wrapper, other.path).trigger('click')
+    await wrapper.get('[aria-label="Close modal"]').trigger('click')
+    expect(wrapper.emitted('cancel')).toHaveLength(1)
+    expect(wrapper.emitted('select')).toBeUndefined()
+    await wrapper.setProps({ open: false })
+    await wrapper.setProps({ open: true })
+    await flushPromises()
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('true')
+    expect(row(wrapper, other.path).attributes('aria-selected')).toBe('false')
+  })
+
+  it('toggles a selected folder off with a second plain click', async () => {
+    const wrapper = await setup()
+    await row(wrapper, folder.path).trigger('click')
+    await flushPromises()
+    await row(wrapper, folder.path).trigger('click')
+    await flushPromises()
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('false')
+    expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+  })
+
+  it('toggles inherited files off and on without a modifier or losing the folder', async () => {
+    const wrapper = await setup()
+    await row(wrapper, folder.path).trigger('click')
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click')
+    expect(row(wrapper, one.path).attributes('aria-selected')).toBe('false')
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('true')
+    await row(wrapper, one.path).trigger('click')
+    expect(row(wrapper, one.path).attributes('aria-selected')).toBe('true')
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('true')
+  })
+
+  it('toggles a single file off but Enter still confirms a selected file', async () => {
+    const wrapper = await setup({ selectionMode: 'single-file' })
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click')
+    await row(wrapper, one.path).trigger('click')
+    await flushPromises()
+    expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+    await row(wrapper, one.path).trigger('click')
+    await row(wrapper, one.path).trigger('keydown', { key: 'Enter' })
+    await flushPromises()
+    expect(wrapper.emitted('select')).toHaveLength(1)
+  })
+
+  it('deselects one explicit file without losing the other selected files', async () => {
+    const wrapper = await setup({ selectionMode: 'multi-file' })
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click')
+    await row(wrapper, two.path).trigger('click', { ctrlKey: true })
+    await row(wrapper, one.path).trigger('click')
+    expect(row(wrapper, one.path).attributes('aria-selected')).toBe('false')
+    expect(row(wrapper, two.path).attributes('aria-selected')).toBe('true')
+  })
+
+  it('does not undo the first click of a double-click or toggle on keyboard navigation', async () => {
+    const wrapper = await setup({ selectionMode: 'single-file' })
+    await expand(wrapper)
+    await row(wrapper, one.path).trigger('click', { detail: 1 })
+    await row(wrapper, one.path).trigger('click', { detail: 2 })
+    expect(row(wrapper, one.path).attributes('aria-selected')).toBe('true')
+    await row(wrapper, one.path).trigger('keydown', { key: 'ArrowDown' })
+    await row(wrapper, two.path).trigger('keydown', { key: 'End' })
+    expect(row(wrapper, two.path).attributes('aria-selected')).toBe('true')
+  })
+
+  it('offers only server and local files and has a text-only confirm action', async () => {
+    const wrapper = await setup({ sources: ['server', 'localFile'] })
+    expect(
+      wrapper
+        .findAll('[aria-label="Data source"] button')
+        .map((button) => button.attributes('aria-label')),
+    ).toEqual(['Server', 'Local files'])
+    expect(confirm(wrapper).text()).toBe('Use selection')
+    expect(wrapper.get('.mint-picker__receipt > span').text()).toBe('No selection')
+    await wrapper.get('[aria-label="Local files"]').trigger('click')
+    await flushPromises()
+    expect(wrapper.get('[aria-label="Local files"]').attributes('aria-pressed')).toBe('true')
+    expect(wrapper.find('[aria-label="Absolute path"]').exists()).toBe(false)
+    expect(wrapper.text()).toContain('Choose files…')
+  })
+
+  it('does not render sources the host did not supply', async () => {
+    const wrapper = await setup({ sources: ['server'] })
+    expect(wrapper.find('[aria-label="Local files"]').exists()).toBe(false)
+    expect(wrapper.find('[aria-label="This machine"]').exists()).toBe(false)
+  })
+
+  it('retries a failed expanded level and blocks confirmation when validation fails', async () => {
+    const data = adapter()
+    vi.mocked(data.listChildren).mockRejectedValueOnce(new Error('Share unavailable'))
+    const wrapper = await setup({ adapter: data })
+    await row(wrapper, folder.path).trigger('click')
+    await flushPromises()
+    expect(wrapper.text()).toContain('Share unavailable')
+    expect(confirm(wrapper).attributes('disabled')).toBeDefined()
+    await wrapper.get('.mint-picker__preview-error button').trigger('click')
+    await flushPromises()
+    expect(confirm(wrapper).attributes('disabled')).toBeUndefined()
+  })
+
+  it('keyboard disclosure never selects and Escape cancels', async () => {
+    const wrapper = await setup()
+    await row(wrapper, folder.path).trigger('keydown', { key: 'ArrowRight' })
+    await flushPromises()
+    expect(row(wrapper, folder.path).attributes('aria-expanded')).toBe('true')
+    expect(row(wrapper, folder.path).attributes('aria-selected')).toBe('false')
+    await row(wrapper, folder.path).trigger('keydown', { key: 'Escape' })
+    expect(wrapper.emitted('cancel')).toHaveLength(1)
+  })
+})
+
+describe('local metadata and capability validation', () => {
+  it('keeps the original File objects without reading bytes', async () => {
+    const file = new File(['data'], 'run.mzML.gz')
+    const read = vi.spyOn(file, 'arrayBuffer')
+    const data = localFilesAdapter([file])
+    const nodes = await data.listRoot()
+    expect(nodes[0]).toMatchObject({ kind: 'file', format: 'mzML.gz', file })
+    expect(read).not.toHaveBeenCalled()
+    expect(pickerExclusion(nodes[0]!, { formats: ['.MZML.GZ'] })).toBeNull()
+    expect(pickerExclusion(nodes[0]!, { formats: ['raw'] })?.reason).toBe('unsupported')
+    expect(pickerExclusion(nodes[0]!, { formats: ['mzML.gz'], maxBytes: 1 })?.reason).toBe(
+      'tooLarge',
+    )
+  })
+  it('preserves duplicate plain file names as distinct browser selections', async () => {
+    const files = [new File(['a'], 'run.raw'), new File(['b'], 'run.raw')]
+    const nodes = await localFilesAdapter(files).listRoot()
+    expect(new Set(nodes.map((node) => node.path)).size).toBe(2)
+    expect(nodes.map((node) => node.kind === 'file' && node.file)).toEqual(files)
+  })
+})

package/src/__tests__/composables/useFileBrowser.test.ts

@@ -0,0 +1,305 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+
+const mockGet = vi.fn()
+vi.mock('../../composables/useApi', () => ({
+  useApi: () => ({ get: mockGet }),
+}))
+
+import { effectScope, nextTick, ref } from 'vue'
+
+import { useFileBrowser } from '../../composables/useFileBrowser'
+
+const MOUNTS = {
+  mounts: [
+    { id: 'seq', label: '/mnt/sequencer-01', available: false },
+    { id: 'qe', label: '/mnt/instrument-qe', available: true },
+  ],
+}
+
+const LISTING = {
+  mount_id: 'qe',
+  path: 'raw',
+  parent: '',
+  breadcrumbs: [{ label: '/mnt/instrument-qe', path: '' }, { label: 'raw', path: 'raw' }],
+  entries: [
+    { name: 'blanks', path: 'raw/blanks', kind: 'directory', child_count: 6 },
+    { name: 'a.raw', path: 'raw/a.raw', kind: 'file', size_bytes: 10, extension: '.raw' },
+  ],
+  total_count: 2,
+  match_count: 1,
+}
+
+beforeEach(() => {
+  mockGet.mockReset()
+})
+
+describe('useFileBrowser', () => {
+  it('should load the configured mounts', async () => {
+    mockGet.mockResolvedValueOnce(MOUNTS).mockResolvedValueOnce(LISTING)
+    const browser = useFileBrowser()
+    await browser.init()
+
+    expect(browser.mounts.value.map(m => m.id)).toEqual(['seq', 'qe'])
+  })
+
+  // An offline mount must not be the one we open on.
+  it('should open the first available mount', async () => {
+    mockGet.mockResolvedValueOnce(MOUNTS).mockResolvedValueOnce(LISTING)
+    const browser = useFileBrowser()
+    await browser.init()
+
+    expect(mockGet.mock.calls[1][0]).toContain('mount_id=qe')
+  })
+
+  // 'nas' is listed after 'qe', so choosing it proves the preference is honoured
+  // rather than the first-available fallback happening to win.
+  it('should honour an explicit initial mount when it is reachable', async () => {
+    mockGet
+      .mockResolvedValueOnce({ mounts: [...MOUNTS.mounts, { id: 'nas', label: '/mnt/nas', available: true }] })
+      .mockResolvedValueOnce(LISTING)
+    const browser = useFileBrowser({ initialMountId: 'nas' })
+    await browser.init()
+
+    expect(mockGet.mock.calls[1][0]).toContain('mount_id=nas')
+  })
+
+  it('should expose the listing entries', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.entries.value.map(e => e.name)).toEqual(['blanks', 'a.raw'])
+  })
+
+  it('should expose the breadcrumb trail', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.breadcrumbs.value.map(c => c.label)).toEqual(['/mnt/instrument-qe', 'raw'])
+  })
+
+  it('should send the configured type rules', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser({ typeRules: ['.raw', '.mzML'] })
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(mockGet.mock.calls[0][0]).toContain('type_rules=.raw&type_rules=.mzML')
+  })
+
+  it('should surface a listing failure', async () => {
+    mockGet.mockRejectedValue(new Error('Mount is offline'))
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.error.value).toContain('Mount is offline')
+  })
+
+  it('should empty the listing when a request fails', async () => {
+    mockGet.mockRejectedValue(new Error('nope'))
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.entries.value).toEqual([])
+  })
+
+  // A slow response for the folder you left must not overwrite the one you are in.
+  it('should ignore a superseded listing response', async () => {
+    let resolveSlow: (value: unknown) => void = () => {}
+    const slow = new Promise(resolve => { resolveSlow = resolve })
+    mockGet.mockReturnValueOnce(slow).mockResolvedValueOnce(LISTING)
+
+    const browser = useFileBrowser()
+    const first = browser.navigate({ mount_id: 'qe', path: 'stale' })
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    resolveSlow({ ...LISTING, path: 'stale', entries: [] })
+    await first
+
+    expect(browser.path.value).toBe('raw')
+  })
+
+  it('should take the current folder into the selection', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    browser.selectCurrentFolder()
+
+    expect(browser.selected.value).toMatchObject([{ mount_id: 'qe', path: 'raw', kind: 'directory' }])
+  })
+
+  it('should not take the same folder twice', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    browser.selectCurrentFolder()
+    browser.selectCurrentFolder()
+
+    expect(browser.selected.value).toHaveLength(1)
+  })
+
+  it('should clear the selection', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    browser.selectCurrentFolder()
+    browser.clear()
+
+    expect(browser.selected.value).toEqual([])
+  })
+
+  it('should report the unfiltered total count', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.totalCount.value).toBe(2)
+  })
+
+  it('should not be loading once a request settles', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.isLoading.value).toBe(false)
+  })
+})
+
+describe('useFileBrowser review fixes', () => {
+  it('should skip an offline mount even when named as the initial one', async () => {
+    mockGet.mockResolvedValueOnce(MOUNTS).mockResolvedValueOnce(LISTING)
+    const browser = useFileBrowser({ initialMountId: 'seq' })
+    await browser.init()
+
+    expect(mockGet.mock.calls[1][0]).toContain('mount_id=qe')
+  })
+
+  // No configured mounts means the routes are absent, not that browsing failed.
+  it('should treat a 404 mount list as no mounts configured', async () => {
+    mockGet.mockRejectedValue({ response: { status: 404 } })
+    const browser = useFileBrowser()
+    await browser.init()
+
+    expect(browser.error.value).toBeNull()
+  })
+
+  it('should leave the mount list empty when none are configured', async () => {
+    mockGet.mockRejectedValue({ response: { status: 404 } })
+    const browser = useFileBrowser()
+    await browser.init()
+
+    expect(browser.mounts.value).toEqual([])
+  })
+
+  it('should surface the API error detail rather than the status code', async () => {
+    mockGet.mockRejectedValue({
+      response: { status: 404, data: { detail: "Mount 'nas' is not available" } },
+      message: 'Request failed with status code 404',
+    })
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'nas', path: '' })
+
+    expect(browser.error.value).toBe("Mount 'nas' is not available")
+  })
+
+  it('should refetch when the sort changes', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    const before = mockGet.mock.calls.length
+    browser.sort.value = 'size'
+    await new Promise(resolve => setTimeout(resolve, 0))
+
+    expect(mockGet.mock.calls.length).toBeGreaterThan(before)
+  })
+
+  it('should refetch when the search changes', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    const before = mockGet.mock.calls.length
+    browser.search.value = 'hela'
+    await new Promise(resolve => setTimeout(resolve, 400))
+
+    expect(mockGet.mock.calls.length).toBeGreaterThan(before)
+  })
+
+  it('should expose how many rows the listing carries', async () => {
+    mockGet.mockResolvedValue({ ...LISTING, shown_count: 2 })
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.shownCount.value).toBe(2)
+  })
+
+  it('should expose a truncated listing', async () => {
+    mockGet.mockResolvedValue({ ...LISTING, truncated: true })
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+
+    expect(browser.truncated.value).toBe(true)
+  })
+})
+
+
+describe('useFileBrowser selection and request lifecycle', () => {
+  it('never selects an uninitialized or failed directory', async () => {
+    const browser = useFileBrowser()
+    browser.selectCurrentFolder()
+    expect(browser.selected.value).toEqual([])
+    mockGet.mockRejectedValueOnce(new Error('offline'))
+    await browser.navigate({ mount_id: 'nas', path: 'runs' })
+    browser.selectCurrentFolder()
+    expect(browser.selected.value).toEqual([])
+  })
+
+  it('retries the failed destination rather than returning to the previous folder', async () => {
+    mockGet.mockResolvedValueOnce(LISTING).mockRejectedValueOnce(new Error('offline')).mockResolvedValueOnce({ ...LISTING, path: 'new' })
+    const browser = useFileBrowser()
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    await browser.navigate({ mount_id: 'qe', path: 'new' })
+    await browser.refresh()
+    expect(mockGet.mock.calls.at(-1)?.[0]).toContain('path=new')
+  })
+
+  it('does not let obsolete requests keep the current directory loading', async () => {
+    let finish!: (value: unknown) => void
+    mockGet.mockReturnValueOnce(new Promise(resolve => { finish = resolve })).mockResolvedValueOnce(LISTING)
+    const browser = useFileBrowser()
+    const old = browser.navigate({ mount_id: 'qe', path: 'old' })
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    expect(browser.isLoading.value).toBe(false)
+    finish(LISTING)
+    await old
+  })
+
+  it('refreshes when reactive type rules change', async () => {
+    mockGet.mockResolvedValue(LISTING)
+    const typeRules = ref(['.raw'])
+    const scope = effectScope()
+    const browser = scope.run(() => useFileBrowser({ typeRules }))!
+    await browser.navigate({ mount_id: 'qe', path: 'raw' })
+    typeRules.value = ['.mzML']
+    await nextTick()
+    expect(mockGet.mock.calls.at(-1)?.[0]).toContain('type_rules=.mzML')
+    scope.stop()
+  })
+
+  it('disposes a pending search without issuing another request', async () => {
+    vi.useFakeTimers()
+    const scope = effectScope()
+    try {
+      mockGet.mockResolvedValue(LISTING)
+      const browser = scope.run(() => useFileBrowser())!
+      await browser.navigate({ mount_id: 'qe', path: 'raw' })
+      browser.search.value = 'abc'
+      await nextTick()
+      const calls = mockGet.mock.calls.length
+      scope.stop()
+      await vi.advanceTimersByTimeAsync(300)
+      expect(mockGet).toHaveBeenCalledTimes(calls)
+    } finally {
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+})