@morscherlab/mint-sdk 1.0.63 → 1.1.0-beta.10

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

@@ -2,7 +2,12 @@ import { mount } from '@vue/test-utils'
 import { defineComponent, nextTick, ref, shallowRef } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
 
-import { useJobsStatusTray, type UseJobsStatusTrayOptions } from '../../composables/useJobsStatusTray'
+import {
+  combinePluginJobSources,
+  useJobsStatusTray,
+  usePluginJobCenter,
+  type UseJobsStatusTrayOptions,
+} from '../../composables/useJobsStatusTray'
 import type { JobState, JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
@@ -62,6 +67,179 @@ function deferred<T>(): {
 }
 
 describe('useJobsStatusTray', () => {
+  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')])
+    const firstRefresh = vi.fn(async () => firstJobs.value)
+    const secondRefresh = vi.fn(async () => secondJobs.value)
+    const secondCancel = vi.fn(async (jobId: string) => job('cancelled', jobId))
+    const firstClear = vi.fn(async () => 1)
+    const secondClear = vi.fn(async () => 2)
+    const firstDispose = vi.fn()
+    const secondDispose = vi.fn()
+    const combined = combinePluginJobSources([
+      {
+        jobs: firstJobs,
+        refreshJobs: firstRefresh,
+        clearFinishedJobs: firstClear,
+        dispose: firstDispose,
+      },
+      {
+        jobs: secondJobs,
+        refreshJobs: secondRefresh,
+        cancelJob: secondCancel,
+        clearFinishedJobs: secondClear,
+        dispose: secondDispose,
+      },
+    ])
+
+    expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'second'])
+    secondJobs.value = [job('running', 'replacement')]
+    await nextTick()
+    expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'replacement'])
+
+    await combined.refreshJobs?.()
+    await combined.cancelJob?.('replacement')
+    await expect(combined.clearFinishedJobs?.()).resolves.toBe(3)
+    combined.dispose?.()
+
+    expect({
+      refreshes: [firstRefresh.mock.calls.length, secondRefresh.mock.calls.length],
+      cancelled: secondCancel.mock.calls[0]?.[0],
+      disposed: [firstDispose.mock.calls.length, secondDispose.mock.calls.length],
+    }).toEqual({
+      refreshes: [1, 1],
+      cancelled: 'replacement',
+      disposed: [1, 1],
+    })
+  })
+
+  it('retains every failure when disposing combined sources', () => {
+    const firstFailure = new Error('first dispose failed')
+    const secondFailure = { source: 'second', reason: 'dispose failed' }
+    const finalDispose = vi.fn()
+    const combined = combinePluginJobSources([
+      {
+        jobs: [],
+        dispose: () => {
+          throw firstFailure
+        },
+      },
+      {
+        jobs: [],
+        dispose: () => {
+          throw secondFailure
+        },
+      },
+      { jobs: [], dispose: finalDispose },
+    ])
+
+    let failure: unknown
+    try {
+      combined.dispose?.()
+    } catch (cause) {
+      failure = cause
+    }
+
+    expect(failure).toMatchObject({
+      name: 'PluginJobSourceDisposeError',
+      message: 'Failed to dispose plugin job sources',
+      cause: firstFailure,
+      errors: [firstFailure, secondFailure],
+    })
+    expect(finalDispose).toHaveBeenCalledOnce()
+  })
+
+  it('rejects duplicate ids instead of routing to an arbitrary combined source', async () => {
+    const firstCancel = vi.fn(async () => undefined)
+    const secondCancel = vi.fn(async () => undefined)
+    const combined = combinePluginJobSources([
+      { jobs: [job('running', 'duplicate')], cancelJob: firstCancel },
+      { jobs: [job('queued', 'duplicate')], cancelJob: secondCancel },
+    ])
+
+    expect(() => combined.jobs.value).toThrow('Duplicate plugin job id')
+    await expect(combined.cancelJob?.('duplicate')).rejects.toThrow('Duplicate plugin job id')
+    expect([firstCancel.mock.calls.length, secondCancel.mock.calls.length]).toEqual([0, 0])
+  })
+
+  it('does not expose a partial bulk clear across combined sources', () => {
+    const combined = combinePluginJobSources([
+      { jobs: [job('completed', 'first')], clearFinishedJobs: async () => 1 },
+      { jobs: [job('completed', 'second')] },
+    ])
+
+    expect(combined.clearFinishedJobs).toBeUndefined()
+  })
+
+  it('does not partially delete finished jobs when one combined source cannot delete', async () => {
+    const firstDelete = vi.fn(async () => true)
+    const combined = combinePluginJobSources([
+      { jobs: [job('completed', 'first')], deleteJob: firstDelete },
+      { jobs: [job('completed', 'second')] },
+    ])
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({ source: combined, loadOnMount: false })
+        return () => null
+      },
+    }))
+
+    expect(combined.deleteJob).toBeUndefined()
+    expect(center.canClearFinished.value).toBe(false)
+    await expect(center.clearFinished()).resolves.toBe(false)
+    expect(firstDelete).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+
+  it('derives jobs directly from a canonical source ref', async () => {
+    const sourceJobs = shallowRef([job('queued', 'first')])
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({
+          source: { jobs: sourceJobs },
+          loadOnMount: false,
+        })
+        return () => null
+      },
+    }))
+
+    sourceJobs.value = [job('running', 'replacement')]
+    await nextTick()
+
+    expect(center.jobs.value.map(item => item.job_id)).toEqual(['replacement'])
+    wrapper.unmount()
+  })
+
+  it('delegates actions by id and leaves source mutation with the source', async () => {
+    const sourceJobs = shallowRef([job('running', 'fit')])
+    const cancelJob = vi.fn(async (jobId: string) => {
+      sourceJobs.value = [job('cancelled', jobId)]
+      return sourceJobs.value[0]
+    })
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({
+          source: { jobs: sourceJobs, cancelJob },
+          loadOnMount: false,
+        })
+        return () => null
+      },
+    }))
+
+    await center.cancelJob(center.jobs.value[0]!)
+
+    expect([cancelJob.mock.calls[0]?.[0], center.jobs.value[0]?.status]).toEqual([
+      'fit',
+      'cancelled',
+    ])
+    wrapper.unmount()
+  })
+
   it('keeps awaiting input jobs in the active group', () => {
     const { tray } = mountComposable({
       jobs: [job('awaiting_input')],

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

@@ -17,6 +17,11 @@ vi.mock('vue', async () => {
 })
 
 import { usePlatformContext } from '../../composables/usePlatformContext'
+import type { PlatformContext } from '../../types'
+
+type InjectedPlatformWindow = Window & {
+  __MINT_PLATFORM__?: PlatformContext
+}
 
 function sendThemeMessage(origin: string, theme: 'light' | 'dark' | 'system'): void {
   if (!messageHandler) {
@@ -37,6 +42,7 @@ describe('usePlatformContext', () => {
   beforeEach(() => {
     unmountedCallbacks.length = 0
     messageHandler = null
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
 
     vi.spyOn(window, 'addEventListener').mockImplementation((type, listener) => {
       if (type === 'message') {
@@ -51,9 +57,31 @@ describe('usePlatformContext', () => {
       const callback = unmountedCallbacks.pop()
       callback?.()
     }
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
     vi.restoreAllMocks()
   })
 
+  it('preserves the injected plugin settings API capability', () => {
+    const injectedContext: PlatformContext = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'test-plugin',
+        name: 'test-plugin',
+        version: '1.0.0',
+        route_prefix: '/test-plugin',
+        api_prefix: '/api/test-plugin',
+        settings_api: 'plugin',
+      },
+    }
+    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = injectedContext
+
+    const context = usePlatformContext()
+
+    expect(context.plugin.value?.settings_api).toBe('plugin')
+  })
+
   it('clears allowAnyOrigin policy after last consumer unmounts', () => {
     const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})