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

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

@@ -1,169 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it, vi } from 'vitest'
-import { h, nextTick } from 'vue'
-import RackEditor from '../../components/RackEditor.vue'
-import type { Rack, WellEditData } from '../../types'
-
-function makeRacks(): Rack[] {
-  return [
-    {
-      id: 'rack-1',
-      name: 'Rack 1',
-      format: 54,
-      slot: 'R',
-      injectionVolume: 5,
-      wells: {
-        A1: {
-          id: 'A1',
-          row: 0,
-          col: 0,
-          state: 'filled',
-          sampleType: 'sample',
-          metadata: {
-            label: 'Original',
-            injectionVolume: 5,
-            injectionCount: 1,
-          },
-        },
-      },
-    },
-  ]
-}
-
-function jsonDataTransfer(data: unknown): DataTransfer {
-  return {
-    dropEffect: 'copy',
-    effectAllowed: 'copy',
-    getData: (type: string) => type === 'application/json' ? JSON.stringify(data) : '',
-    setData: vi.fn(),
-  } as unknown as DataTransfer
-}
-
-describe('RackEditor', () => {
-  it('keeps rack selection and removal as sibling buttons', () => {
-    const racks = makeRacks()
-    racks.push({ ...racks[0], id: 'rack-2', name: 'Rack 2', wells: {} })
-    const wrapper = mount(RackEditor, { props: { modelValue: racks } })
-
-    expect(wrapper.find('.mint-rack-editor__tab button').exists()).toBe(false)
-    expect(wrapper.get('.mint-rack-editor__tab-item').findAll('button')).toHaveLength(2)
-  })
-
-  it('passes rack-aware well editor slot props through to WellPlate', async () => {
-    const wrapper = mount(RackEditor, {
-      props: {
-        modelValue: makeRacks(),
-      },
-      slots: {
-        'well-editor': (slotProps) => h(
-          'button',
-          {
-            'data-test': 'custom-well-editor',
-            onClick: () => slotProps.save({
-              wellId: slotProps.wellId,
-              label: 'Custom',
-              sampleType: 'iqc',
-              injectionVolume: 7,
-              injectionCount: 3,
-              customMethod: 'C:\\Methods\\custom.meth',
-            } satisfies WellEditData),
-          },
-          `${slotProps.rackId}:${slotProps.rack?.slot}:${slotProps.wellId}:${slotProps.wellData?.metadata?.label}`,
-        ),
-      },
-    })
-
-    await wrapper.find('.mint-well-plate__well').trigger('click')
-
-    const customEditor = wrapper.get('[data-test="custom-well-editor"]')
-    expect(customEditor.text()).toBe('rack-1:R:A1:Original')
-
-    await customEditor.trigger('click')
-    await nextTick()
-
-    const emittedRacks = wrapper.emitted('update:modelValue')?.at(-1)?.[0] as Rack[]
-    expect(emittedRacks[0].wells.A1).toMatchObject({
-      sampleType: 'iqc',
-      metadata: {
-        label: 'Custom',
-        injectionVolume: 7,
-        injectionCount: 3,
-        customMethod: 'C:\\Methods\\custom.meth',
-      },
-    })
-  })
-
-  it('assigns dropped external samples when sample drop is enabled', async () => {
-    const wrapper = mount(RackEditor, {
-      props: {
-        modelValue: makeRacks(),
-        allowSampleDrop: true,
-      },
-    })
-
-    await wrapper.findAll('.mint-well-plate__well')[1].trigger('drop', {
-      dataTransfer: jsonDataTransfer({
-        type: 'sample',
-        id: 'sample-2',
-        sampleName: 'Dragged Sample',
-      }),
-      preventDefault: vi.fn(),
-    })
-    await nextTick()
-
-    const emittedRacks = wrapper.emitted('update:modelValue')?.at(-1)?.[0] as Rack[]
-    expect(emittedRacks[0].wells.A2).toMatchObject({
-      sampleType: 'sample',
-      metadata: {
-        label: 'Dragged Sample',
-        injectionVolume: 5,
-        injectionCount: 1,
-        customMethod: null,
-      },
-    })
-
-    expect(wrapper.emitted('sample-drop')?.[0]?.slice(0, 3)).toEqual([
-      'rack-1',
-      'A2',
-      expect.objectContaining({
-        id: 'sample-2',
-        sampleName: 'Dragged Sample',
-      }),
-    ])
-  })
-
-  it('reorders rack tabs with Alt and the arrow keys', async () => {
-    const racks = makeRacks()
-    racks.push({ ...racks[0], id: 'rack-2', name: 'Rack 2', slot: 'G', wells: {} })
-
-    const wrapper = mount(RackEditor, { props: { modelValue: racks } })
-
-    await wrapper.findAll('.mint-rack-editor__tab')[0].trigger('keydown', {
-      key: 'ArrowRight',
-      altKey: true,
-    })
-    await nextTick()
-
-    expect(wrapper.emitted('rack-reorder')?.at(-1)?.[0]).toEqual(['rack-2', 'rack-1'])
-    expect(wrapper.findAll('.mint-rack-editor__tab').map(tab => tab.text()))
-      .toEqual([expect.stringContaining('Rack 2'), expect.stringContaining('Rack 1')])
-    expect(wrapper.get('[role="status"]').attributes('aria-live')).toBe('polite')
-  })
-
-  it('does not reorder rack tabs from the keyboard when reordering is off', async () => {
-    const racks = makeRacks()
-    racks.push({ ...racks[0], id: 'rack-2', name: 'Rack 2', slot: 'G', wells: {} })
-
-    const wrapper = mount(RackEditor, {
-      props: { modelValue: racks, allowReorder: false },
-    })
-
-    await wrapper.findAll('.mint-rack-editor__tab')[0].trigger('keydown', {
-      key: 'ArrowRight',
-      altKey: true,
-    })
-    await nextTick()
-
-    expect(wrapper.emitted('rack-reorder')).toBeUndefined()
-  })
-})

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

@@ -1,233 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { createPinia, setActivePinia } from 'pinia'
-import axios from 'axios'
-
-vi.mock('axios')
-const mockedAxios = vi.mocked(axios, true)
-
-const unmountedCallbacks: Array<() => void> = []
-
-// Mock vue lifecycle hooks since we're not in a component
-vi.mock('vue', async () => {
-  const actual = await vi.importActual<typeof import('vue')>('vue')
-  return {
-    ...actual,
-    getCurrentInstance: vi.fn(() => ({})),
-    onMounted: vi.fn((cb: () => void) => cb()),
-    onUnmounted: vi.fn((cb: () => void) => {
-      unmountedCallbacks.push(cb)
-    }),
-  }
-})
-
-import { useAuth, _resetAuthStateForTesting } from '../../composables/useAuth'
-import { useAuthStore } from '../../stores/auth'
-import { useSettingsStore } from '../../stores/settings'
-
-describe('useAuth', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    vi.clearAllMocks()
-    vi.useFakeTimers()
-    unmountedCallbacks.length = 0
-    _resetAuthStateForTesting()
-
-    // Mock settings store
-    const settingsStore = useSettingsStore()
-    settingsStore.getApiBaseUrl = vi.fn(() => 'http://localhost:8000')
-
-    // Mock localStorage
-    const storage: Record<string, string> = {}
-    vi.stubGlobal('localStorage', {
-      getItem: vi.fn((key: string) => storage[key] ?? null),
-      setItem: vi.fn((key: string, val: string) => { storage[key] = val }),
-      removeItem: vi.fn((key: string) => { delete storage[key] }),
-    })
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-    vi.restoreAllMocks()
-  })
-
-  it('loads the PostgreSQL-only public auth contract', async () => {
-    mockedAxios.get.mockResolvedValueOnce({
-      data: {
-        auth_required: true,
-        passkey_enabled: true,
-        passkey_registered: false,
-        registration_enabled: true,
-        database_mode: 'postgresql',
-        access: { experiment_visibility_mode: 'restricted' },
-      },
-    })
-
-    const config = await useAuth().fetchAuthConfig()
-    const expected = {
-      authRequired: true,
-      passkeyEnabled: true,
-      passkeyRegistered: false,
-      registrationEnabled: true,
-      databaseMode: 'postgresql',
-      experimentVisibilityMode: 'restricted',
-    }
-
-    expect([config, useAuthStore().authConfig]).toEqual([expected, expected])
-  })
-
-  describe('login', () => {
-    it('should set token on successful login', async () => {
-      mockedAxios.post.mockResolvedValueOnce({
-        data: { access_token: 'test-token', expires_in: 3600, token_type: 'bearer' },
-      })
-      mockedAxios.get.mockResolvedValueOnce({
-        data: { id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true },
-      })
-
-      const { login } = useAuth()
-      const result = await login('test', 'password')
-
-      expect(result).toBe(true)
-      const authStore = useAuthStore()
-      expect(authStore.token).toBe('test-token')
-    })
-
-    it('should return false on failed login', async () => {
-      mockedAxios.post.mockRejectedValueOnce({
-        isAxiosError: true,
-        response: { data: { detail: 'Invalid credentials' }, status: 401 },
-      })
-      // @ts-expect-error -- vitest mock assignment
-      mockedAxios.isAxiosError = vi.fn(() => true)
-
-      const { login } = useAuth()
-      const result = await login('test', 'wrong')
-
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('logout', () => {
-    it('should clear token on logout', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('test-token', 3600)
-
-      const { logout } = useAuth()
-      logout()
-
-      expect(authStore.token).toBeNull()
-    })
-  })
-
-  describe('storage fallback', () => {
-    it('keeps auth usable when localStorage operations throw', () => {
-      vi.stubGlobal('localStorage', {
-        getItem: vi.fn(() => { throw new Error('blocked') }),
-        setItem: vi.fn(() => { throw new Error('blocked') }),
-        removeItem: vi.fn(() => { throw new Error('blocked') }),
-      })
-
-      const authStore = useAuthStore()
-
-      expect(() => authStore.initialize()).not.toThrow()
-
-      authStore.setToken('memory-token', 3600)
-      expect(authStore.token).toBe('memory-token')
-
-      authStore.clearToken()
-      expect(authStore.token).toBeNull()
-    })
-  })
-
-  describe('refreshToken - race condition', () => {
-    it('should deduplicate concurrent refresh calls', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('old-token', 3600)
-
-      let resolveRefresh: (value: unknown) => void
-      const refreshPromise = new Promise((resolve) => {
-        resolveRefresh = resolve
-      })
-
-      mockedAxios.post.mockImplementation(() => refreshPromise as Promise<unknown>)
-
-      const { refreshToken } = useAuth()
-
-      // Fire two concurrent refreshes
-      const p1 = refreshToken()
-      const p2 = refreshToken()
-
-      // Both should return the same promise
-      resolveRefresh!({
-        data: { access_token: 'new-token', expires_in: 3600, token_type: 'bearer' },
-      })
-
-      const [r1, r2] = await Promise.all([p1, p2])
-      expect(r1).toBe(true)
-      expect(r2).toBe(true)
-
-      // axios.post should have been called only once
-      expect(mockedAxios.post).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('refreshToken - lifecycle behavior', () => {
-    it('keeps scheduled refresh when one of multiple consumers unmounts', async () => {
-      mockedAxios.post.mockImplementation((url: string) => {
-        if (url.endsWith('/auth/login')) {
-          return Promise.resolve({
-            data: { access_token: 'test-token', expires_in: 301, token_type: 'bearer' },
-          })
-        }
-        if (url.endsWith('/auth/refresh')) {
-          return Promise.resolve({
-            data: { access_token: 'refreshed-token', expires_in: 3600, token_type: 'bearer' },
-          })
-        }
-        throw new Error(`Unexpected POST ${url}`)
-      })
-      mockedAxios.get.mockResolvedValue({
-        data: { id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true },
-      })
-
-      const authA = useAuth()
-      useAuth()
-
-      await authA.login('test', 'password')
-
-      expect(unmountedCallbacks).toHaveLength(2)
-      unmountedCallbacks[0]!()
-
-      vi.advanceTimersByTime(2_000)
-      await Promise.resolve()
-
-      const refreshCalls = mockedAxios.post.mock.calls.filter(
-        ([url]) => typeof url === 'string' && url.endsWith('/auth/refresh'),
-      )
-      expect(refreshCalls).toHaveLength(1)
-
-      unmountedCallbacks[1]!()
-    })
-  })
-
-  describe('verifyToken', () => {
-    it('should return false when no token', async () => {
-      const { verifyToken } = useAuth()
-      const result = await verifyToken()
-      expect(result).toBe(false)
-    })
-
-    it('should return true on valid token', async () => {
-      const authStore = useAuthStore()
-      authStore.setToken('valid-token', 3600)
-
-      mockedAxios.get.mockResolvedValueOnce({
-        data: { valid: true, username: 'testuser' },
-      })
-
-      const { verifyToken } = useAuth()
-      const result = await verifyToken()
-      expect(result).toBe(true)
-    })
-  })
-})

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

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { useCommandHistory, type CommandHistoryCommand } from '../../composables/useCommandHistory'
-
-describe('useCommandHistory', () => {
-  it('executes commands and tracks undo/redo stacks', () => {
-    const values: string[] = []
-    const command: CommandHistoryCommand = {
-      description: 'Add A',
-      execute: () => { values.push('A') },
-      undo: () => { values.pop() },
-    }
-    const history = useCommandHistory()
-
-    history.execute(command)
-
-    expect(values).toEqual(['A'])
-    expect(history.canUndo.value).toBe(true)
-    expect(history.undoDescription.value).toBe('Add A')
-
-    history.undo()
-    expect(values).toEqual([])
-    expect(history.canRedo.value).toBe(true)
-    expect(history.redoDescription.value).toBe('Add A')
-
-    history.redo()
-    expect(values).toEqual(['A'])
-    expect(history.canUndo.value).toBe(true)
-  })
-
-  it('enforces max depth and supports skipExecute', () => {
-    const values: number[] = []
-    const history = useCommandHistory({ maxDepth: 2 })
-
-    history.execute({ execute: () => { values.push(1) }, undo: () => undefined })
-    history.execute({ execute: () => { values.push(2) }, undo: () => undefined })
-    history.execute({ execute: () => { values.push(3) }, undo: () => undefined })
-    history.execute({ execute: () => { values.push(4) }, undo: () => undefined }, { skipExecute: true })
-
-    expect(values).toEqual([1, 2, 3])
-    expect(history.undoStack.value).toHaveLength(2)
-  })
-})

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

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { useOptimisticMutation } from '../../composables/useOptimisticMutation'
-
-describe('useOptimisticMutation', () => {
-  it('applies optimistic state and commits server data', async () => {
-    const items = ['A']
-    const mutation = useOptimisticMutation<string, string, string[]>({
-      snapshot: () => [...items],
-      apply: value => { items.push(value) },
-      mutation: async (value: string) => value.toLowerCase(),
-      commit: result => { items[items.length - 1] = result },
-    })
-
-    const result = await mutation.run('B')
-
-    expect(result).toBe('b')
-    expect(items).toEqual(['A', 'b'])
-    expect(mutation.loading.value).toBe(false)
-    expect(mutation.error.value).toBeNull()
-  })
-
-  it('rolls back and rethrows failed mutations', async () => {
-    const items = ['A']
-    const failure = new Error('backend rejected')
-    const mutation = useOptimisticMutation<string, never, string[]>({
-      snapshot: () => [...items],
-      apply: value => { items.push(value) },
-      mutation: async () => { throw failure },
-      rollback: snapshot => {
-        items.splice(0, items.length, ...(snapshot ?? []))
-      },
-    })
-
-    await expect(mutation.run('B')).rejects.toThrow('backend rejected')
-
-    expect(items).toEqual(['A'])
-    expect(mutation.error.value).toBe('backend rejected')
-  })
-})