@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

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

@@ -2,10 +2,11 @@ import { flushPromises, mount } from '@vue/test-utils'
 import { createPinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import ArtifactSelectorModal from '../../components/ArtifactSelectorModal.vue'
 import FileUploader from '../../components/FileUploader.vue'
 import GeneratedPathInput from '../../components/GeneratedPathInput.vue'
-import type { AnalysisArtifactDetail } from '../../types/analysisArtifactTypes'
+import { GENERATED_JOBS_API_KEY } from '../../components/internal/generatedJobsApi'
+import type { GeneratedAnalysisTransport } from '../../composables/useGeneratedAnalysis'
+import type { PluginJobPathInput } from '../../types/generated-ui'
 
 describe('GeneratedPathInput', () => {
   beforeEach(() => {
@@ -101,50 +102,176 @@ describe('GeneratedPathInput', () => {
     expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toBeNull()
   })
 
-  it('should download a selected platform file artifact for staging', async () => {
-    const fetcher = vi.fn().mockResolvedValue(new Response('artifact-data', {
-      headers: { 'Content-Type': 'text/csv' },
-    }))
-    vi.stubGlobal('fetch', fetcher)
+  const readableRow = {
+    id: 7,
+    experiment_id: 42,
+    plugin_id: 'leaf',
+    artifact_key: 'matrix',
+    display_name: 'Matrix',
+    status: 'active',
+    result_keys: ['schema_version', 'file'],
+    created_at: '2026-09-20T10:00:00Z',
+    updated_at: '2026-09-20T10:00:00Z',
+    filename: 'matrix.csv',
+  }
+
+  const artifactSelection = {
+    kind: 'artifact-path',
+    experimentId: 42,
+    artifactId: 7,
+    name: 'matrix.csv',
+  } as const
+
+  function listing(rows: unknown[] = [readableRow], status = 200) {
+    return vi.fn<GeneratedAnalysisTransport>().mockResolvedValue(
+      new Response(JSON.stringify(status === 200 ? { artifacts: rows } : { detail: 'Forbidden' }), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    )
+  }
+
+  function mountWithJobsApi(
+    transport: GeneratedAnalysisTransport,
+    props: Record<string, unknown> = {},
+  ) {
+    return mount(GeneratedPathInput, {
+      props,
+      global: {
+        plugins: [createPinia()],
+        stubs: { Teleport: true },
+        provide: { [GENERATED_JOBS_API_KEY as symbol]: { baseUrl: '/api/demo', transport } },
+      },
+    })
+  }
+
+  async function openPicker(wrapper: ReturnType<typeof mountWithJobsApi>): Promise<void> {
+    const button = wrapper.findAll('button').find(candidate => candidate.text() === 'Existing artifact')
+    await button!.trigger('click')
+    await flushPromises()
+  }
+
+  it('should list only the artifacts the plugin jobs API says it can read', async () => {
+    const transport = listing()
+    const wrapper = mountWithJobsApi(transport)
+
+    await openPicker(wrapper)
+
+    expect(transport.mock.calls[0]?.[0]).toBe('/api/demo/jobs/artifacts?experiment_id=42')
+  })
+
+  it('should keep a picked artifact as a server reference', async () => {
+    const wrapper = mountWithJobsApi(listing())
+    await openPicker(wrapper)
+
+    await wrapper.get('[role="option"]').trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toEqual(artifactSelection)
+  })
+
+  it('should not download artifact bytes when an artifact is picked', async () => {
+    const transport = listing()
+    const wrapper = mountWithJobsApi(transport)
+    await openPicker(wrapper)
+
+    await wrapper.get('[role="option"]').trigger('click')
+    await flushPromises()
+
+    expect(transport).toHaveBeenCalledTimes(1)
+  })
+
+  it('should explain that no artifact is readable when the list is empty', async () => {
+    const wrapper = mountWithJobsApi(listing([]))
+
+    await openPicker(wrapper)
+
+    expect(wrapper.text()).toContain('No file artifacts this plugin can read')
+  })
+
+  it('should show why the artifact list could not be loaded', async () => {
+    const wrapper = mountWithJobsApi(listing([], 403))
+
+    await openPicker(wrapper)
+
+    expect(wrapper.text()).toContain('Forbidden')
+  })
+
+  it('should ignore a slower listing from an earlier opening of the picker', async () => {
+    let releaseFirst: (response: Response) => void = () => undefined
+    const stale = new Promise<Response>((resolve) => { releaseFirst = resolve })
+    const transport = vi.fn<GeneratedAnalysisTransport>()
+      .mockReturnValueOnce(stale)
+      .mockResolvedValueOnce(new Response(JSON.stringify({ artifacts: [readableRow] })))
+    const wrapper = mountWithJobsApi(transport)
+    await openPicker(wrapper)
+    await openPicker(wrapper)
+
+    releaseFirst(new Response(JSON.stringify({ artifacts: [] })))
+    await flushPromises()
+
+    expect(wrapper.findAll('[role="option"]')).toHaveLength(1)
+  })
+
+  it('should list artifacts under a jobs API base given with a trailing slash', async () => {
+    const transport = listing()
+    const wrapper = mount(GeneratedPathInput, {
+      global: {
+        plugins: [createPinia()],
+        stubs: { Teleport: true },
+        provide: { [GENERATED_JOBS_API_KEY as symbol]: { baseUrl: '/api/demo/', transport } },
+      },
+    })
+
+    await openPicker(wrapper as ReturnType<typeof mountWithJobsApi>)
+
+    expect(transport.mock.calls[0]?.[0]).toBe('/api/demo/jobs/artifacts?experiment_id=42')
+  })
+
+  it('should hide the artifact choice outside a generated jobs workspace', () => {
     const wrapper = mount(GeneratedPathInput, {
       global: { plugins: [createPinia()], stubs: { Teleport: true } },
     })
-    const detail = {
-      id: 7,
-      experiment_id: 42,
-      plugin_id: 'leaf',
-      artifact_key: 'matrix',
-      display_name: 'Matrix',
-      status: 'active',
-      result_keys: ['file'],
-      tree: [],
-      summary: null,
-      result: {
-        schema_version: 'mint.analysis_file.v1',
-        filename: 'matrix.csv',
-        file: {
-          key: 'analysis-artifacts/matrix/v1/matrix.csv',
-          plugin_id: 'leaf',
-          experiment_id: 42,
-        },
-      },
-    } satisfies AnalysisArtifactDetail
 
-    wrapper.findComponent(ArtifactSelectorModal).vm.$emit('selectDetail', detail)
-    await flushPromises()
+    expect(wrapper.text()).not.toContain('Existing artifact')
+  })
 
-    const selection = wrapper.emitted('update:modelValue')?.at(-1)?.[0] as {
-      files: File[]
-      relativePaths: string[]
-    }
-    expect({
-      url: fetcher.mock.calls[0]?.[0],
-      filename: selection.files[0]?.name,
-      relativePaths: selection.relativePaths,
-    }).toEqual({
-      url: '/api/experiments/42/objects/analysis-artifacts/matrix/v1/matrix.csv?plugin_id=leaf&format=raw',
-      filename: 'matrix.csv',
-      relativePaths: ['matrix.csv'],
+  it('should show the selected artifact by name when the model holds one', () => {
+    const wrapper = mount(GeneratedPathInput, {
+      props: { modelValue: artifactSelection },
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
     })
+
+    expect(wrapper.get('.mint-generated-path-input__artifact').text()).toContain('matrix.csv')
+  })
+
+  it('should clear the model when the selected artifact is removed', async () => {
+    const wrapper = mount(GeneratedPathInput, {
+      props: { modelValue: artifactSelection },
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+    })
+
+    await wrapper.get('button[aria-label="Remove matrix.csv"]').trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toBeNull()
+  })
+
+  it('should append a picked artifact to existing selections when multiple paths are requested', async () => {
+    const file = new File(['a'], 'a.txt')
+    const upload: PluginJobPathInput = { kind: 'path', files: [file], relativePaths: ['a.txt'] }
+    const wrapper = mountWithJobsApi(listing(), { multiple: true, modelValue: [upload] })
+    await openPicker(wrapper)
+
+    await wrapper.get('[role="option"]').trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toEqual([upload, artifactSelection])
+  })
+
+  it('should keep the selected artifact locked while the input is disabled', () => {
+    const wrapper = mount(GeneratedPathInput, {
+      props: { modelValue: artifactSelection, disabled: true },
+      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+    })
+
+    expect(wrapper.get('button[aria-label="Remove matrix.csv"]').attributes('disabled')).toBeDefined()
   })
 })

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

@@ -116,7 +116,7 @@ describe('GeneratedPlotlyResult', () => {
       expect.any(HTMLElement),
       [trace],
       expect.objectContaining({ autosize: true }),
-      { responsive: true, displaylogo: false },
+      { responsive: true, displaylogo: false, displayModeBar: false, showSendToCloud: false },
     )
   })
 

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

@@ -1,11 +1,16 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
+import { flushPromises, mount } from '@vue/test-utils'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import ChartContainer from '../../components/ChartContainer.vue'
 import DataFrame from '../../components/DataFrame.vue'
 import GeneratedResultRenderer from '../../components/GeneratedResultRenderer.vue'
 
 describe('GeneratedResultRenderer', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    vi.restoreAllMocks()
+  })
+
   it('renders tabular results with the standard DataFrame component', () => {
     const wrapper = mount(GeneratedResultRenderer, {
       props: {
@@ -90,4 +95,44 @@ describe('GeneratedResultRenderer', () => {
       download: 'large.msd',
     })
   })
+
+  describe('managed file downloads', () => {
+    const managed = {
+      kind: 'artifact' as const,
+      id: 'artifact-2',
+      name: 'large.msd',
+      media_type: 'application/octet-stream',
+      size: 3,
+      download_url: '/api/leaf/jobs/job-1/result/file/scoped-token',
+      managed: true,
+    }
+
+    async function clickDownload(): Promise<{ fetch: ReturnType<typeof vi.fn>, saved: string[] }> {
+      vi.stubGlobal('localStorage', { getItem: (key: string) => (key === 'mint-auth-token' ? 'session-jwt' : null) })
+      const fetch = vi.fn(async () => new Response('msd'))
+      vi.stubGlobal('fetch', fetch)
+      vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:managed')
+      vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {})
+      const saved: string[] = []
+      vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(function (this: HTMLAnchorElement) {
+        saved.push(this.download)
+      })
+      const wrapper = mount(GeneratedResultRenderer, { props: { result: managed } })
+      await wrapper.get('a').trigger('click')
+      await flushPromises()
+      return { fetch, saved }
+    }
+
+    it('should send the Bearer credential when downloading a managed file', async () => {
+      const { fetch } = await clickDownload()
+
+      expect(new Headers(fetch.mock.calls[0]?.[1]?.headers).get('Authorization')).toBe('Bearer session-jwt')
+    })
+
+    it('should save the fetched file under the artifact name when downloading a managed file', async () => {
+      const { saved } = await clickDownload()
+
+      expect(saved).toEqual(['large.msd'])
+    })
+  })
 })

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

@@ -0,0 +1,50 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import InstrumentStateBadge from '../../components/InstrumentStateBadge.vue'
+
+describe('InstrumentStateBadge', () => {
+  it('should render a status dot when the state does not pulse', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'idle' } })
+    expect(wrapper.find('.mint-instrument-state__dot').exists()).toBe(true)
+  })
+
+  it('should label known states in sentence case when no label is given', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'disconnected' } })
+    expect(wrapper.text()).toBe('Offline')
+  })
+
+  it('should pulse the dot when the instrument is running', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'RUNNING' } })
+    expect(wrapper.classes()).toContain('mint-instrument-state--pulse')
+  })
+
+  it('should use the info tone when the instrument is running', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'running' } })
+    expect(wrapper.classes()).toContain('mint-instrument-state--info')
+  })
+
+  it('should use the success tone when the instrument is connected', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'connected' } })
+    expect(wrapper.classes()).toContain('mint-instrument-state--success')
+  })
+
+  it('should use the dash shape when the instrument never reported', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'never' } })
+    expect(wrapper.classes()).toContain('mint-instrument-state--never')
+  })
+
+  it('should label the never state as never reported', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'never' } })
+    expect(wrapper.text()).toBe('Never reported')
+  })
+
+  it('should use the square shape when the instrument is inactive', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'inactive' } })
+    expect(wrapper.classes()).toContain('mint-instrument-state--inactive')
+  })
+
+  it('should label the inactive state as inactive', () => {
+    const wrapper = mount(InstrumentStateBadge, { props: { state: 'inactive' } })
+    expect(wrapper.text()).toBe('Inactive')
+  })
+})

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

@@ -162,4 +162,31 @@ describe('JobsStatusTray', () => {
     const history = wrapper.findAll('[data-testid="open"]')
     expect(history.map((b) => b.attributes('data-job'))).toEqual(['C-1'])
   })
+
+  it('should pin awaiting-input jobs to the top when they arrive after other active jobs', async () => {
+    const wrapper = await openTray({
+      source: { jobs: [job('running', 'R-1'), job('queued', 'Q-1'), job('awaiting_input', 'A-1')] },
+    })
+    expect(wrapper.findAll('.mint-jobs-tray__job-select').map((b) => b.text()))
+      .toEqual(['Job A-1', 'Job R-1', 'Job Q-1'])
+  })
+
+  it('should tint the awaiting-input row when a job waits for input', async () => {
+    const wrapper = await openTray({ source: { jobs: [job('awaiting_input')] } })
+    expect(wrapper.get('.mint-jobs-tray__job').classes()).toContain('mint-jobs-tray__job--awaiting-input')
+  })
+
+  it('should show a mono percent next to the status when a job is running', async () => {
+    const running = job('running')
+    running.progress = { ...running.progress, percent: 62 }
+    const wrapper = await openTray({ source: { jobs: [running] } })
+    expect(wrapper.get('.mint-jobs-tray__percent').text()).toBe('62%')
+  })
+
+  it('should summarize active jobs by state in the header when jobs are active', async () => {
+    const wrapper = await openTray({
+      source: { jobs: [job('running', 'R-1'), job('queued', 'Q-1'), job('awaiting_input', 'A-1')] },
+    })
+    expect(wrapper.get('.mint-jobs-tray__subtitle').text()).toBe('1 running · 1 queued · 1 waiting')
+  })
 })

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

@@ -0,0 +1,78 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import MoleculeInput from '../../components/MoleculeInput.vue'
+
+type JSMEWindow = Window & {
+  __jsmeLoaded__?: boolean
+  __jsmeLoadPromise__?: Promise<void>
+  JSApplet?: { JSME?: new (...args: unknown[]) => unknown }
+  jsmeOnLoad?: () => void
+}
+
+const jsmeWindow = window as JSMEWindow
+const happyDOMSettings = (window as unknown as {
+  happyDOM: { settings: { handleDisabledFileLoadingAsSuccess: boolean } }
+}).happyDOM.settings
+
+beforeEach(() => {
+  // A browser loads the CDN script asynchronously; happy-dom would fail it synchronously.
+  happyDOMSettings.handleDisabledFileLoadingAsSuccess = true
+})
+
+afterEach(() => {
+  happyDOMSettings.handleDisabledFileLoadingAsSuccess = false
+  vi.restoreAllMocks()
+  delete jsmeWindow.__jsmeLoaded__
+  delete jsmeWindow.__jsmeLoadPromise__
+  delete jsmeWindow.JSApplet
+  delete jsmeWindow.jsmeOnLoad
+  document.querySelectorAll('script[data-jsme]').forEach(script => script.remove())
+  vi.useRealTimers()
+})
+
+describe('MoleculeInput', () => {
+  it('does not create an editor after the component is unmounted', async () => {
+    let resolveLoad!: () => void
+    jsmeWindow.__jsmeLoadPromise__ = new Promise<void>(resolve => { resolveLoad = resolve })
+    const createEditor = vi.fn()
+    const wrapper = mount(MoleculeInput)
+
+    wrapper.unmount()
+    jsmeWindow.JSApplet = { JSME: createEditor as unknown as new () => unknown }
+    resolveLoad()
+    await flushPromises()
+
+    expect(createEditor).not.toHaveBeenCalled()
+  })
+
+  it('should remove the failed script when the JSME load errors', async () => {
+    const wrapper = mount(MoleculeInput)
+    document.querySelector('script[data-jsme]')?.dispatchEvent(new Event('error'))
+    await flushPromises()
+
+    expect(document.querySelector('script[data-jsme]')).toBeNull()
+    wrapper.unmount()
+  })
+
+  it('should clear the cached loader when the JSME load times out', async () => {
+    vi.useFakeTimers()
+    const wrapper = mount(MoleculeInput)
+    await vi.advanceTimersByTimeAsync(15000)
+
+    expect(jsmeWindow.__jsmeLoadPromise__).toBeUndefined()
+    wrapper.unmount()
+  })
+
+  it('should clear the cached loader when an existing script never initializes', async () => {
+    vi.useFakeTimers()
+    const stale = document.createElement('script')
+    stale.setAttribute('data-jsme', 'true')
+    document.head.appendChild(stale)
+    const wrapper = mount(MoleculeInput)
+    await vi.advanceTimersByTimeAsync(15000)
+
+    expect(jsmeWindow.__jsmeLoadPromise__).toBeUndefined()
+    wrapper.unmount()
+  })
+})

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

@@ -45,4 +45,10 @@ describe('MultiSelect', () => {
     expect(wrapper.emitted('update:modelValue')).toBeUndefined()
     expect(wrapper.findAll('button')[1].attributes('disabled')).toBeDefined()
   })
+
+  it('should reserve the check slot on every chip when only one is selected', () => {
+    const wrapper = mount(MultiSelect, { props: { modelValue: ['a'], options } })
+
+    expect(wrapper.findAll('.mint-multi-select__chip-check')).toHaveLength(3)
+  })
 })