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

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

@@ -1,497 +0,0 @@
-/**
- * Tests for usePluginConfig.
- *
- * Covers the plugin settings life-cycle used by every plugin's
- * settings pane:
- *
- * - resolvedName prefers explicit pluginName, falls back to platform plugin
- * - load() populates config + savedConfig from /plugins/{name}/config
- * - save() PATCHes the endpoint, updates savedConfig, returns true
- * - isDirty reflects user edits vs last saved state
- * - reset() restores config to savedConfig and clears error
- * - lastLoadedAt / lastSavedAt track successful syncs
- * - error messages bubble up from network failures
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createPinia, setActivePinia } from 'pinia'
-import axios, { type AxiosRequestConfig } from 'axios'
-import { nextTick } from 'vue'
-
-// usePluginConfig calls onMounted(load); happy-dom doesn't run Vue's
-// lifecycle outside a component, so we stub onMounted to call the
-// callback synchronously if and only if the test opts in.
-let autoLoadOnMount = false
-vi.mock('vue', async () => {
-  const actual = await vi.importActual<typeof import('vue')>('vue')
-  return {
-    ...actual,
-    onMounted: vi.fn((cb: () => void) => {
-      if (autoLoadOnMount) cb()
-    }),
-  }
-})
-
-import { usePluginConfig } from '../../composables/usePluginConfig'
-
-type FakeResponse = Record<string, unknown>
-
-let getResponse: FakeResponse = { plugin_name: 'drp', config: {} }
-let patchResponse: FakeResponse = { plugin_name: 'drp', config: {} }
-let putResponse: FakeResponse = { plugin_name: 'drp', config: {} }
-let getError: Error | null = null
-let patchError: Error | null = null
-let recordedBaseUrls: Array<string | undefined> = []
-let recordedCalls: {
-  method: string
-  url: string
-  data?: unknown
-  headers?: AxiosRequestConfig['headers']
-}[] = []
-
-function mockAxios() {
-  vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
-    this: unknown,
-    url: string,
-    config?: AxiosRequestConfig,
-  ) {
-    recordedBaseUrls.push(config?.baseURL)
-    recordedCalls.push({ method: 'GET', url })
-    if (getError) throw getError
-    return { data: getResponse }
-  })
-  vi.spyOn(axios.Axios.prototype, 'patch').mockImplementation(async function (
-    this: unknown,
-    url: string,
-    data?: unknown,
-    config?: AxiosRequestConfig,
-  ) {
-    recordedBaseUrls.push(config?.baseURL)
-    recordedCalls.push({ method: 'PATCH', url, data })
-    if (patchError) throw patchError
-    return { data: patchResponse }
-  })
-  vi.spyOn(axios.Axios.prototype, 'put').mockImplementation(async function (
-    this: unknown,
-    url: string,
-    data?: unknown,
-    config?: AxiosRequestConfig,
-  ) {
-    recordedBaseUrls.push(config?.baseURL)
-    recordedCalls.push({ method: 'PUT', url, data, headers: config?.headers })
-    return { data: putResponse }
-  })
-}
-
-describe('usePluginConfig', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    autoLoadOnMount = false
-    getResponse = { plugin_name: 'drp', config: {} }
-    patchResponse = { plugin_name: 'drp', config: {} }
-    putResponse = { plugin_name: 'drp', config: {} }
-    getError = null
-    patchError = null
-    recordedCalls = []
-    recordedBaseUrls = []
-    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
-    mockAxios()
-  })
-
-  afterEach(() => {
-    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
-    vi.restoreAllMocks()
-  })
-
-  it('load fetches config from correct endpoint and populates state', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: { raw_files_path: '/data/rfa', threshold: 0.5 },
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-
-    expect(recordedCalls).toEqual([
-      { method: 'GET', url: '/plugins/drp/config' },
-    ])
-    expect(hook.config.value).toEqual({
-      raw_files_path: '/data/rfa',
-      threshold: 0.5,
-    })
-    expect(hook.isDirty.value).toBe(false)
-    expect(hook.error.value).toBeNull()
-    expect(hook.lastLoadedAt.value).toBeInstanceOf(Date)
-  })
-
-  it('encodes special characters in plugin name', async () => {
-    const hook = usePluginConfig('my/plugin')
-    await hook.load()
-    expect(recordedCalls[0]!.url).toBe('/plugins/my%2Fplugin/config')
-  })
-
-  it.each([
-    'platform',
-    undefined,
-  ] as const)(
-    'should use the platform config facade when settings_api is %s',
-    async (settingsApi) => {
-      ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-        isIntegrated: true,
-        theme: 'light',
-        platformApiUrl: '/api',
-        plugin: {
-          id: 'drp',
-          name: 'drp',
-          version: '1.0.0',
-          route_prefix: '/drp',
-          api_prefix: '/api/drp',
-          ...(settingsApi ? { settings_api: settingsApi } : {}),
-        },
-      }
-      getResponse = {
-        plugin_name: 'drp',
-        config: { n: 1 },
-        revision: 'revision-1',
-      }
-      const hook = usePluginConfig('drp')
-
-      await hook.load()
-
-      expect(recordedCalls).toEqual([
-        { method: 'GET', url: '/plugins/drp/config' },
-      ])
-    },
-  )
-
-  it('should use the plugin settings router for an integrated plugin capability', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'drp',
-        name: 'drp',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/drp',
-        settings_api: 'plugin',
-      },
-    }
-    getResponse = {
-      settings: { n: 1 },
-      mode: 'integrated',
-      revision: 'revision-1',
-    }
-    putResponse = {
-      settings: { n: 2 },
-      mode: 'integrated',
-      revision: 'revision-2',
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = { n: 2 }
-
-    const saved = await hook.save()
-
-    expect({
-      saved,
-      calls: recordedCalls,
-      baseUrls: recordedBaseUrls,
-      config: hook.config.value,
-    }).toEqual({
-      saved: true,
-      baseUrls: ['/api/drp', '/api/drp'],
-      calls: [
-        { method: 'GET', url: '/settings' },
-        {
-          method: 'PUT',
-          url: '/settings',
-          data: { n: 2 },
-          headers: { 'If-Match': '"revision-1"' },
-        },
-      ],
-      config: { n: 2 },
-    })
-  })
-
-  it('should use the platform facade for an explicit different plugin name', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'current-plugin',
-        name: 'current-plugin',
-        version: '1.0.0',
-        route_prefix: '/current-plugin',
-        api_prefix: '/api/current-plugin',
-        settings_api: 'plugin',
-      },
-    }
-    getResponse = {
-      plugin_name: 'other-plugin',
-      config: { n: 1 },
-      revision: 'revision-1',
-    }
-
-    const hook = usePluginConfig('other-plugin')
-    await hook.load()
-
-    expect({
-      calls: recordedCalls,
-      config: hook.config.value,
-    }).toEqual({
-      calls: [
-        { method: 'GET', url: '/plugins/other-plugin/config' },
-      ],
-      config: { n: 1 },
-    })
-  })
-
-  it('should PATCH only dirty typed fields through a versioned platform facade', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 2,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-2',
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = {
-      n: 2,
-      allowed_experiment_types: ['metabolomics'],
-    }
-    await nextTick()
-    expect(hook.isDirty.value).toBe(true)
-
-    const ok = await hook.save()
-    expect(ok).toBe(true)
-    const patchCall = recordedCalls.find((c) => c.method === 'PATCH')!
-    expect(patchCall.url).toBe('/plugins/drp/config')
-    expect(patchCall.data).toEqual({ config: { n: 2 } })
-    expect(patchCall.headers).toBeUndefined()
-    expect(hook.config.value).toEqual({
-      n: 2,
-      allowed_experiment_types: ['metabolomics'],
-    })
-    expect(hook.isDirty.value).toBe(false)
-    expect(hook.lastSavedAt.value).toBeInstanceOf(Date)
-  })
-
-  it('should split changed platform-owned config from a versioned typed save', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 2,
-        allowed_experiment_types: ['proteomics'],
-      },
-      revision: 'untrusted-platform-revision',
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = {
-      n: 2,
-      allowed_experiment_types: ['proteomics'],
-    }
-
-    const saved = await hook.save()
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 3,
-        allowed_experiment_types: ['proteomics'],
-      },
-      revision: 'revision-3',
-    }
-    hook.config.value = {
-      n: 3,
-      allowed_experiment_types: ['proteomics'],
-    }
-    const savedAgain = await hook.save()
-
-    expect({
-      saved,
-      savedAgain,
-      calls: recordedCalls,
-      config: hook.config.value,
-      isDirty: hook.isDirty.value,
-    }).toEqual({
-      saved: true,
-      savedAgain: true,
-      calls: [
-        { method: 'GET', url: '/plugins/drp/config' },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { n: 2 } },
-        },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { allowed_experiment_types: ['proteomics'] } },
-        },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { n: 3 } },
-        },
-      ],
-      config: {
-        n: 3,
-        allowed_experiment_types: ['proteomics'],
-      },
-      isDirty: false,
-    })
-  })
-
-  it('should avoid a typed PUT when only the platform-owned config changes', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    patchResponse = {
-      plugin_name: 'drp',
-      config: {
-        n: 1,
-        allowed_experiment_types: ['proteomics'],
-      },
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = {
-      n: 1,
-      allowed_experiment_types: ['proteomics'],
-    }
-
-    const saved = await hook.save()
-
-    expect({
-      saved,
-      calls: recordedCalls,
-      config: hook.config.value,
-    }).toEqual({
-      saved: true,
-      calls: [
-        { method: 'GET', url: '/plugins/drp/config' },
-        {
-          method: 'PATCH',
-          url: '/plugins/drp/config',
-          data: { config: { allowed_experiment_types: ['proteomics'] } },
-        },
-      ],
-      config: {
-        n: 1,
-        allowed_experiment_types: ['proteomics'],
-      },
-    })
-  })
-
-  it('should detect nested config edits and restore the saved JSON snapshot', async () => {
-    getResponse = {
-      plugin_name: 'drp',
-      config: {
-        rules: {
-          thresholds: [1, 2],
-        },
-      },
-    }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    const rules = hook.config.value.rules as { thresholds: number[] }
-    rules.thresholds[0] = 9
-    await nextTick()
-
-    const dirtyAfterMutation = hook.isDirty.value
-    hook.reset()
-
-    expect({
-      dirtyAfterMutation,
-      config: hook.config.value,
-      isDirty: hook.isDirty.value,
-    }).toEqual({
-      dirtyAfterMutation: true,
-      config: {
-        rules: {
-          thresholds: [1, 2],
-        },
-      },
-      isDirty: false,
-    })
-  })
-
-  it('isDirty reflects edits vs last saved snapshot', async () => {
-    getResponse = { plugin_name: 'drp', config: { k: 'v' } }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    expect(hook.isDirty.value).toBe(false)
-
-    hook.config.value = { k: 'changed' }
-    await nextTick()
-    expect(hook.isDirty.value).toBe(true)
-
-    hook.config.value = { k: 'v' }
-    await nextTick()
-    expect(hook.isDirty.value).toBe(false)
-  })
-
-  it('reset restores saved config and clears error', async () => {
-    getResponse = { plugin_name: 'drp', config: { k: 'v' } }
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = { k: 'edited' }
-    hook.error.value = 'something'
-
-    hook.reset()
-    expect(hook.config.value).toEqual({ k: 'v' })
-    expect(hook.error.value).toBeNull()
-  })
-
-  it('load surfaces network error message', async () => {
-    getError = new Error('network down')
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    expect(hook.error.value).toBe('network down')
-    expect(hook.isLoading.value).toBe(false)
-    expect(hook.lastLoadedAt.value).toBeNull()
-  })
-
-  it('save returns false and records error on failure', async () => {
-    patchError = new Error('403')
-    const hook = usePluginConfig('drp')
-    await hook.load()
-    hook.config.value = { x: 1 }
-    const ok = await hook.save()
-    expect(ok).toBe(false)
-    expect(hook.error.value).toBe('403')
-    expect(hook.lastSavedAt.value).toBeNull()
-  })
-
-  it('empty plugin name produces a noop load', async () => {
-    const hook = usePluginConfig('')
-    await hook.load()
-    expect(recordedCalls).toEqual([])
-    expect(hook.error.value).toBeNull()
-  })
-})