@morscherlab/mint-sdk 1.1.25 → 1.2.0-beta.10

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

@@ -0,0 +1,140 @@
+import { effectScope } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { useEventStream } from '../../composables/useEventStream'
+
+function pendingStreamResponse(): {
+  response: Response
+  close: () => void
+} {
+  let close!: () => void
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      close = () => {
+        try {
+          controller.close()
+        } catch {
+          // stop() may already have cancelled the reader.
+        }
+      }
+    },
+  })
+  return { response: new Response(body), close }
+}
+
+describe('useEventStream', () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('should decode chunked UTF-8 and dispatch an unterminated multiline tail frame', async () => {
+    const encoded = new TextEncoder().encode(
+      ': keepalive\nevent: result\nid: event-7\ndata: first\ndata: 2 µmol',
+    )
+    const split = encoded.indexOf(0xc2) + 1
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoded.slice(0, split))
+        controller.enqueue(encoded.slice(split))
+        controller.close()
+      },
+    })
+    const onMessage = vi.fn()
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport: vi.fn(async () => new Response(body)),
+      reconnect: false,
+      onMessage,
+    }))!
+
+    await vi.waitFor(() => expect(onMessage).toHaveBeenCalledOnce())
+
+    expect(stream.lastMessage.value).toEqual({
+      event: 'result',
+      data: 'first\n2 µmol',
+      id: 'event-7',
+      retry: undefined,
+      raw: ': keepalive\nevent: result\nid: event-7\ndata: first\ndata: 2 µmol',
+    })
+    scope.stop()
+  })
+
+  it('should keep server retry delay local and send Last-Event-ID on reconnect', async () => {
+    vi.useFakeTimers()
+    const first = new Response('id: event-1\nretry: 7\ndata: first\n\n')
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(first)
+      .mockResolvedValueOnce(second.response)
+    const options = {
+      transport,
+      reconnectDelayMs: 1_000,
+    }
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', options))!
+
+    await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-1'))
+    await vi.advanceTimersByTimeAsync(7)
+
+    const secondHeaders = new Headers(transport.mock.calls[1]?.[1]?.headers)
+    expect({
+      attempts: transport.mock.calls.length,
+      lastEventId: secondHeaders.get('Last-Event-ID'),
+      configuredDelay: options.reconnectDelayMs,
+    }).toEqual({
+      attempts: 2,
+      lastEventId: 'event-1',
+      configuredDelay: 1_000,
+    })
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+
+  it('should apply control-only frames without dispatching a data message', async () => {
+    vi.useFakeTimers()
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(new Response('id: event-2\nretry: 7\n\n'))
+      .mockResolvedValueOnce(second.response)
+    const onMessage = vi.fn()
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport,
+      reconnectDelayMs: 1_000,
+      onMessage,
+    }))!
+
+    await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-2'))
+    await vi.advanceTimersByTimeAsync(7)
+
+    expect({
+      messages: onMessage.mock.calls.length,
+      reconnectCursor: new Headers(transport.mock.calls[1]?.[1]?.headers).get('Last-Event-ID'),
+    }).toEqual({ messages: 0, reconnectCursor: 'event-2' })
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+
+  it('should reconnect after an ordinary stream close', async () => {
+    vi.useFakeTimers()
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(new Response('data: first\n\n'))
+      .mockResolvedValueOnce(second.response)
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport,
+      reconnectDelayMs: 5,
+    }))!
+
+    await vi.waitFor(() => expect(stream.lastMessage.value?.data).toBe('first'))
+    await vi.advanceTimersByTimeAsync(5)
+
+    expect(transport).toHaveBeenCalledTimes(2)
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+})

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

@@ -126,6 +126,28 @@ function activeJob(
   }
 }
 
+function streamingJobTransport(): ReturnType<typeof vi.fn<GeneratedAnalysisTransport>> {
+  return vi.fn<GeneratedAnalysisTransport>(async (input, init) => {
+    const url = String(input)
+    if (url.endsWith('/generated/manifest')) return response(manifest)
+    if (url.endsWith('/jobs/sessions') && init?.method === 'GET') {
+      return response({ sessions: [] })
+    }
+    if (url.endsWith('/jobs/sessions') && init?.method === 'POST') {
+      return response({
+        id: 'session-1',
+        tab_id: 'tab-1',
+        created_at: '',
+        last_seen_at: '',
+        active_job_ids: [],
+      })
+    }
+    if (url.endsWith('/jobs/events')) return eventStream()
+    if (url.endsWith('/jobs')) return response({ jobs: [activeJob('job-1')] })
+    throw new Error(`Unexpected request: ${url}`)
+  })
+}
+
 describe('useGeneratedAnalysis', () => {
   it('is directly usable as a job center source', () => {
     const scope = effectScope()
@@ -283,6 +305,87 @@ describe('useGeneratedAnalysis', () => {
     }
   })
 
+  it('should poll active jobs while a closed stream waits to reconnect', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 1_000,
+    }))!
+
+    try {
+      await generated.initialize()
+      await vi.advanceTimersByTimeAsync(5)
+
+      expect(transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs'))).toHaveLength(2)
+    } finally {
+      generated.dispose()
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+
+  it('should not poll or reconnect a paused job stream', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 10,
+    }))!
+
+    try {
+      await generated.initialize()
+      await vi.advanceTimersByTimeAsync(0)
+      generated.pause()
+      await vi.advanceTimersByTimeAsync(20)
+
+      expect({
+        jobLists: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs')).length,
+        streams: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs/events')).length,
+      }).toEqual({ jobLists: 1, streams: 1 })
+    } finally {
+      generated.dispose()
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+
+  it('should not poll or reconnect a disposed job stream', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 10,
+    }))!
+
+    await generated.initialize()
+    await vi.advanceTimersByTimeAsync(0)
+    generated.dispose()
+    await vi.advanceTimersByTimeAsync(20)
+
+    expect({
+      jobLists: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs')).length,
+      streams: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs/events')).length,
+    }).toEqual({ jobLists: 1, streams: 1 })
+    scope.stop()
+    vi.useRealTimers()
+  })
+
   it('does not let a late submit response regress a terminal stream update', async () => {
     const terminal = completedJob('fast-service-job')
     const lateQueued = activeJob('fast-service-job')

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

@@ -1,14 +1,13 @@
 import { mount } from '@vue/test-utils'
-import { defineComponent, nextTick, ref, shallowRef } from 'vue'
+import { defineComponent, nextTick, shallowRef } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
 
 import {
   combinePluginJobSources,
-  useJobsStatusTray,
   usePluginJobCenter,
-  type UseJobsStatusTrayOptions,
+  type UsePluginJobCenterOptions,
 } from '../../composables/useJobsStatusTray'
-import type { JobState, JobStateInput, JobStatus } from '../../types/jobs'
+import type { JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
   return {
@@ -44,29 +43,18 @@ function job(status: JobStatus, id: string = status): JobStateInput {
   }
 }
 
-function mountComposable(options: UseJobsStatusTrayOptions) {
-  let tray!: ReturnType<typeof useJobsStatusTray>
+function mountComposable(options: UsePluginJobCenterOptions) {
+  let tray!: ReturnType<typeof usePluginJobCenter>
   const wrapper = mount(defineComponent({
     setup() {
-      tray = useJobsStatusTray(options)
+      tray = usePluginJobCenter(options)
       return () => null
     },
   }))
   return { tray, wrapper }
 }
 
-function deferred<T>(): {
-  promise: Promise<T>
-  resolve: (value: T) => void
-} {
-  let resolve!: (value: T) => void
-  const promise = new Promise<T>((done) => {
-    resolve = done
-  })
-  return { promise, resolve }
-}
-
-describe('useJobsStatusTray', () => {
+describe('usePluginJobCenter', () => {
   it('combines live source jobs and fans out or routes source actions', async () => {
     const firstJobs = shallowRef([job('running', 'first')])
     const secondJobs = shallowRef([job('completed', 'second')])
@@ -242,37 +230,20 @@ describe('useJobsStatusTray', () => {
 
   it('keeps awaiting input jobs in the active group', () => {
     const { tray } = mountComposable({
-      jobs: [job('awaiting_input')],
+      source: { jobs: [job('awaiting_input')] },
       loadOnMount: false,
     })
 
     expect(tray.activeJobs.value.map(item => item.job_id)).toEqual(['awaiting_input'])
   })
 
-  it('replaces stale jobs when an SSE snapshot arrives', () => {
-    const { tray } = mountComposable({ jobs: [job('running', 'old')], loadOnMount: false })
-
-    tray.applyStreamMessage({
-      event: 'snapshot',
-      data: { jobs: [job('queued', 'new')] },
-    })
-
-    expect(tray.jobs.value.map(item => item.job_id)).toEqual(['new'])
-  })
-
-  it('moves an SSE terminal update into history', () => {
-    const { tray } = mountComposable({ jobs: [job('running', 'fit')], loadOnMount: false })
-
-    tray.applyStreamMessage({ event: 'terminal', data: job('completed', 'fit') })
-
-    expect(tray.historyJobs.value.map(item => item.job_id)).toEqual(['fit'])
-  })
-
-  it('does not call a cancel adapter when the capability is disabled', async () => {
+  it('does not call a source cancel action when the capability is disabled', async () => {
     const cancelJob = vi.fn()
     const { tray } = mountComposable({
-      jobs: [{ ...job('running'), can_cancel: false }],
-      adapter: { cancelJob },
+      source: {
+        jobs: [{ ...job('running'), can_cancel: false }],
+        cancelJob,
+      },
       loadOnMount: false,
     })
 
@@ -281,139 +252,32 @@ describe('useJobsStatusTray', () => {
     expect(cancelJob).not.toHaveBeenCalled()
   })
 
-  it('does not let a stale list response overwrite an SSE update', async () => {
-    let resolveList!: (jobs: JobStateInput[]) => void
-    const listJobs = vi.fn(() => new Promise<JobStateInput[]>((resolve) => {
-      resolveList = resolve
-    }))
-    const { tray } = mountComposable({
-      adapter: { listJobs },
-      loadOnMount: false,
+  it('refreshes through the source without mirroring its jobs', async () => {
+    const sourceJobs = shallowRef([job('running', 'old')])
+    const refreshJobs = vi.fn(async () => {
+      sourceJobs.value = [job('queued', 'new')]
+      return sourceJobs.value
     })
-
-    const refresh = tray.refresh()
-    tray.applyStreamMessage({ event: 'job', data: job('running', 'live') })
-    resolveList([job('queued', 'stale')])
-    await refresh
-    await nextTick()
-
-    expect(tray.jobs.value.map(item => item.job_id)).toEqual(['live'])
-  })
-
-  it('passes only explicitly deletable jobs to the bulk clear adapter', async () => {
-    const clearFinishedJobs = vi.fn(async (_jobs: readonly JobState[]) => undefined)
     const { tray } = mountComposable({
-      jobs: [
-        job('completed', 'legacy-deletable'),
-        { ...job('failed', 'retained'), can_delete: false },
-      ],
-      adapter: { clearFinishedJobs },
+      source: { jobs: sourceJobs, refreshJobs },
       loadOnMount: false,
     })
 
-    await tray.clearFinished()
+    await tray.refresh()
+    await nextTick()
 
-    expect(clearFinishedJobs.mock.calls[0]![0].map(item => item.job_id)).toEqual([
-      'legacy-deletable',
+    expect([refreshJobs.mock.calls.length, tray.jobs.value.map(item => item.job_id)]).toEqual([
+      1,
+      ['new'],
     ])
   })
 
   it('does not include active deletable jobs in bulk clear targets', () => {
     const { tray } = mountComposable({
-      jobs: [{ ...job('awaiting_input'), can_delete: true }],
+      source: { jobs: [{ ...job('awaiting_input'), can_delete: true }] },
       loadOnMount: false,
     })
 
     expect(tray.deletableJobs.value).toEqual([])
   })
-
-  it('does not let a late cancel response overwrite a newer SSE state', async () => {
-    const pending = deferred<JobStateInput>()
-    const { tray } = mountComposable({
-      jobs: [job('running', 'fit')],
-      adapter: { cancelJob: async () => pending.promise },
-      loadOnMount: false,
-    })
-
-    const cancellation = tray.cancelJob(tray.jobs.value[0]!)
-    tray.applyStreamMessage({ event: 'terminal', data: job('completed', 'fit') })
-    pending.resolve(job('cancelled', 'fit'))
-    await cancellation
-
-    expect(tray.jobs.value[0]!.status).toBe('completed')
-  })
-
-  it('applies a cancel response after an unrelated job update', async () => {
-    const pending = deferred<JobStateInput>()
-    const { tray } = mountComposable({
-      jobs: [job('running', 'fit'), job('running', 'export')],
-      adapter: { cancelJob: async () => pending.promise },
-      loadOnMount: false,
-    })
-
-    const cancellation = tray.cancelJob(tray.jobs.value[0]!)
-    tray.applyStreamMessage({ event: 'job', data: job('running', 'export') })
-    pending.resolve(job('cancelled', 'fit'))
-    await cancellation
-
-    expect(tray.jobs.value.find(item => item.job_id === 'fit')?.status).toBe('cancelled')
-  })
-
-  it('refreshes instead of removing every target after a partial bulk clear', async () => {
-    const listJobs = vi.fn(async () => [job('completed', 'retained')])
-    const clearFinishedJobs = vi.fn(async () => 1)
-    const { tray } = mountComposable({
-      jobs: [job('completed', 'deleted'), job('completed', 'retained')],
-      adapter: { listJobs, clearFinishedJobs },
-      loadOnMount: false,
-    })
-
-    const cleared = await tray.clearFinished()
-
-    expect([
-      cleared,
-      listJobs.mock.calls.length,
-      tray.jobs.value.map(item => item.job_id),
-    ]).toEqual([false, 1, ['retained']])
-  })
-
-  it('uses a replacement reactive adapter for later actions', async () => {
-    const first = vi.fn(async () => undefined)
-    const second = vi.fn(async () => undefined)
-    const adapter = shallowRef({ cancelJob: first })
-    const { tray } = mountComposable({
-      jobs: [job('running')],
-      adapter,
-      loadOnMount: false,
-    })
-    adapter.value = { cancelJob: second }
-
-    await tray.cancelJob(tray.jobs.value[0]!)
-
-    expect([first.mock.calls.length, second.mock.calls.length]).toEqual([0, 1])
-  })
-
-  it('applies the latest message from a replacement stream immediately', async () => {
-    const eventStream = shallowRef({
-      isConnected: ref(true),
-      isConnecting: ref(false),
-      error: ref<string | null>(null),
-      lastMessage: shallowRef({
-        event: 'snapshot',
-        data: { jobs: [job('queued', 'replacement')] },
-        raw: '',
-      }),
-      lastEventId: ref<string | null>(null),
-      start: vi.fn(),
-      stop: vi.fn(),
-    })
-
-    const { tray } = mountComposable({
-      eventStream,
-      loadOnMount: false,
-    })
-    await nextTick()
-
-    expect(tray.jobs.value.map(item => item.job_id)).toEqual(['replacement'])
-  })
 })

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

@@ -0,0 +1,145 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import { defineComponent, nextTick, ref } from 'vue'
+import {
+  reorderList,
+  useListReorder,
+  useReorderAnnouncer,
+  type ListReorderMove,
+} from '../../composables/useListReorder'
+
+interface Row { id: string; name: string }
+
+function mountHarness(onReorder: (move: ListReorderMove<Row>) => void, disabled = false) {
+  const items = ref<Row[]>([
+    { id: 'a', name: 'Alpha' },
+    { id: 'b', name: 'Beta' },
+    { id: 'c', name: 'Gamma' },
+  ])
+
+  const wrapper = mount(defineComponent({
+    setup() {
+      const reorder = useListReorder<Row>({
+        items: () => items.value,
+        getId: (row) => row.id,
+        getLabel: (row) => row.name,
+        disabled: () => disabled,
+        itemNoun: 'Row',
+        onReorder,
+      })
+      return { items, ...reorder }
+    },
+    template: `
+      <ul>
+        <li v-for="(row, index) in items" :key="row.id" :data-id="row.id"
+            @keydown="onKeydown($event, row, index)"
+            @dragstart="onDragStart($event, row, index)"
+            @dragover="onDragOver($event, row, index)"
+            @drop="onDrop($event, row, index)">{{ row.name }}</li>
+      </ul>
+      <p class="announcement">{{ announcement }}</p>
+    `,
+  }), { attachTo: document.body })
+
+  return { wrapper, items }
+}
+
+describe('reorderList', () => {
+  it('returns a copy with the item moved, leaving the source untouched', () => {
+    const source = ['a', 'b', 'c']
+
+    expect(reorderList(source, 0, 2)).toEqual(['b', 'c', 'a'])
+    expect(source).toEqual(['a', 'b', 'c'])
+  })
+})
+
+describe('useReorderAnnouncer', () => {
+  it('publishes messages and re-announces an identical message', async () => {
+    const { announcement, announce } = useReorderAnnouncer()
+
+    announce('Alpha moved.')
+    await nextTick()
+    expect(announcement.value).toBe('Alpha moved.')
+
+    announce('Alpha moved.')
+    expect(announcement.value).toBe('')
+    await nextTick()
+    expect(announcement.value).toBe('Alpha moved.')
+  })
+})
+
+describe('useListReorder', () => {
+  it('moves an item one position later on Alt+ArrowDown and announces it', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowDown', altKey: true })
+
+    expect(onReorder).toHaveBeenCalledTimes(1)
+    const move = onReorder.mock.calls[0][0] as ListReorderMove<Row>
+    expect(move.fromIndex).toBe(0)
+    expect(move.toIndex).toBe(1)
+    expect(move.source).toBe('keyboard')
+    expect(move.items.map(row => row.id)).toEqual(['b', 'a', 'c'])
+
+    await nextTick()
+    expect(wrapper.get('.announcement').text()).toBe('Alpha moved to position 2 of 3.')
+
+    wrapper.unmount()
+  })
+
+  it('moves an item one position earlier on Alt+ArrowUp and Alt+ArrowLeft', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    await wrapper.get('[data-id="c"]').trigger('keydown', { key: 'ArrowUp', altKey: true })
+    await wrapper.get('[data-id="c"]').trigger('keydown', { key: 'ArrowLeft', altKey: true })
+
+    expect(onReorder.mock.calls.map(call => (call[0] as ListReorderMove<Row>).toIndex)).toEqual([1, 1])
+
+    wrapper.unmount()
+  })
+
+  it('ignores arrow keys without Alt and moves past either end', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowDown' })
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowUp', altKey: true })
+    await wrapper.get('[data-id="c"]').trigger('keydown', { key: 'ArrowDown', altKey: true })
+
+    expect(onReorder).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+
+  it('reorders through a drag and clears its drag state', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder)
+
+    const dataTransfer = { effectAllowed: '', dropEffect: '', setData: vi.fn() }
+    await wrapper.get('[data-id="a"]').trigger('dragstart', { dataTransfer })
+    await wrapper.get('[data-id="c"]').trigger('dragover', { dataTransfer })
+    await wrapper.get('[data-id="c"]').trigger('drop', { dataTransfer })
+
+    const move = onReorder.mock.calls[0][0] as ListReorderMove<Row>
+    expect(move).toMatchObject({ fromIndex: 0, toIndex: 2, source: 'drag' })
+    expect(move.items.map(row => row.id)).toEqual(['b', 'c', 'a'])
+    expect(dataTransfer.setData).toHaveBeenCalledWith('text/plain', 'a')
+
+    wrapper.unmount()
+  })
+
+  it('blocks every reorder while disabled', async () => {
+    const onReorder = vi.fn()
+    const { wrapper } = mountHarness(onReorder, true)
+
+    await wrapper.get('[data-id="a"]').trigger('keydown', { key: 'ArrowDown', altKey: true })
+    await wrapper.get('[data-id="a"]').trigger('dragstart', { dataTransfer: { setData: vi.fn() } })
+    await wrapper.get('[data-id="b"]').trigger('drop', { dataTransfer: { setData: vi.fn() } })
+
+    expect(onReorder).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+})