@morscherlab/mint-sdk 1.1.0 → 1.1.1

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

@@ -1,5 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { ref, computed, nextTick } from 'vue'
+import { createPinia, setActivePinia } from 'pinia'
+import axios from 'axios'
 
 // Capture side-effect callbacks so tests can invoke them directly
 let capturedScopeDispose: (() => void) | null = null
@@ -22,6 +24,7 @@ vi.mock('vue', async () => {
 
 import { useAppExperiment, APP_EXPERIMENT_KEY } from '../../composables/useAppExperiment'
 import type { AppExperimentState } from '../../composables/useAppExperiment'
+import { useExperimentStore } from '../../stores/experiment'
 import type { ExperimentSummary } from '../../types'
 
 // ---------------------------------------------------------------------------
@@ -45,6 +48,37 @@ function getState(): AppExperimentState {
   return capturedProvideValue as AppExperimentState
 }
 
+interface PendingFetch {
+  promise: Promise<{ data: ExperimentSummary }>
+  resolveWith: (experiment: ExperimentSummary) => void
+  rejectWith: (error: Error) => void
+}
+
+// Read at call time, not at spy-install time: axios binds its prototype methods
+// into each instance when the instance is created, so a spy installed per test
+// never reaches the client the SDK already built.
+let pendingFetch: PendingFetch | null = null
+
+/**
+ * Holds the platform request open so tests can observe the composable while the
+ * store is mid-resolve — the state an id-only deep link starts in.
+ */
+function stubExperimentFetch(): PendingFetch {
+  let settle!: (result: { data: ExperimentSummary } | Error) => void
+  const promise = new Promise<{ data: ExperimentSummary }>((resolve, reject) => {
+    settle = (result) => {
+      if (result instanceof Error) reject(result)
+      else resolve(result)
+    }
+  })
+  pendingFetch = {
+    promise,
+    resolveWith: (experiment: ExperimentSummary) => settle({ data: experiment }),
+    rejectWith: (error: Error) => settle(error),
+  }
+  return pendingFetch
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -54,6 +88,12 @@ describe('useAppExperiment', () => {
     capturedScopeDispose = null
     capturedProvideKey = null
     capturedProvideValue = null
+    setActivePinia(createPinia())
+    pendingFetch = null
+    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation((() => {
+      if (!pendingFetch) return Promise.reject(new Error('Unexpected platform request'))
+      return pendingFetch.promise
+    }) as never)
     vi.useFakeTimers()
   })
 
@@ -79,107 +119,138 @@ describe('useAppExperiment', () => {
   })
 
   // -------------------------------------------------------------------------
-  // set() and clear()
+  // Store-backed state
   // -------------------------------------------------------------------------
 
-  describe('set', () => {
-    it('should initialize from a direct experiment option', () => {
-      const { experimentName, experimentCode, experimentId } = useAppExperiment({
-        experiment: makeExperiment({ id: 8, name: 'Initial run', experiment_code: 'EXP-008' }),
-      })
+  describe('store-backed experiment state', () => {
+    it('should mirror a record the platform already returned', () => {
+      const { experimentName, experimentCode, experimentId } = useAppExperiment()
 
-      expect(experimentName.value).toBe('Initial run')
-      expect(experimentCode.value).toBe('EXP-008')
-      expect(experimentId.value).toBe(8)
-    })
-
-    it('should sync and clear a reactive experiment option', async () => {
-      const source = ref<ExperimentSummary | null>(
+      useExperimentStore().select(
         makeExperiment({ id: 8, name: 'Initial run', experiment_code: 'EXP-008' }),
       )
-      const { experimentName, experimentCode, experimentId } = useAppExperiment({
-        experiment: source,
-      })
 
       expect(experimentName.value).toBe('Initial run')
       expect(experimentCode.value).toBe('EXP-008')
       expect(experimentId.value).toBe(8)
+    })
 
-      source.value = makeExperiment({ id: 9, name: 'Updated run', experiment_code: 'EXP-009' })
-      await nextTick()
+    it('should leave experimentCode undefined for a record without a code', () => {
+      const { experimentCode } = useAppExperiment()
+
+      useExperimentStore().select(makeExperiment({ id: 7, name: 'Alpha Run' }))
+
+      expect(experimentCode.value).toBeUndefined()
+    })
+
+    it('should follow the store when the selection changes', () => {
+      const store = useExperimentStore()
+      const { experimentName, experimentCode, experimentId } = useAppExperiment()
+
+      store.select(makeExperiment({ id: 8, name: 'Initial run', experiment_code: 'EXP-008' }))
+      store.select(makeExperiment({ id: 9, name: 'Updated run', experiment_code: 'EXP-009' }))
 
       expect(experimentName.value).toBe('Updated run')
       expect(experimentCode.value).toBe('EXP-009')
       expect(experimentId.value).toBe(9)
+    })
 
-      source.value = null
-      await nextTick()
+    it('should expose the status from the store record', () => {
+      useAppExperiment()
+
+      useExperimentStore().select(makeExperiment({ status: 'completed' }))
+
+      expect(getState().experimentStatus.value).toBe('completed')
+    })
+
+    it('should reset when the store is cleared', () => {
+      const store = useExperimentStore()
+      const { experimentName, experimentCode, experimentStatus, experimentId } = useAppExperiment()
+
+      store.select(makeExperiment({ id: 99, name: 'To Be Cleared', experiment_code: 'EXP-099' }))
+      store.clear()
 
       expect(experimentName.value).toBeUndefined()
       expect(experimentCode.value).toBeUndefined()
+      expect(experimentStatus.value).toBeUndefined()
       expect(experimentId.value).toBeNull()
     })
 
-    it('should update experimentName and experimentId on set', () => {
-      const { set, experimentName, experimentCode, experimentId } = useAppExperiment()
-      const experiment = makeExperiment({ id: 7, name: 'Alpha Run' })
+    it('should report isResolving while the store resolves an id', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      const { isResolving } = useAppExperiment()
 
-      set(experiment)
+      const pending = store.selectById(8)
+      expect(isResolving.value).toBe(true)
 
-      expect(experimentName.value).toBe('Alpha Run')
-      expect(experimentCode.value).toBeUndefined()
-      expect(experimentId.value).toBe(7)
+      fetch.resolveWith(makeExperiment({ id: 8, name: 'Resolved run' }))
+      await pending
+
+      expect(isResolving.value).toBe(false)
     })
 
-    it('should update experimentStatus in provided state', () => {
-      const { set } = useAppExperiment()
-      const experiment = makeExperiment({ status: 'completed' })
+    it('should expose the bound id but no name while an id-only binding resolves', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      const { experimentId, experimentName, experimentCode } = useAppExperiment()
 
-      set(experiment)
+      const pending = store.selectById(8)
 
-      expect(getState().experimentStatus.value).toBe('completed')
+      expect(experimentId.value).toBe(8)
+      expect(experimentName.value).toBeUndefined()
+      expect(experimentCode.value).toBeUndefined()
+
+      fetch.resolveWith(makeExperiment({ id: 8, name: 'Resolved run' }))
+      await pending
     })
 
-    it('should overwrite previously set values', () => {
-      const { set, experimentName, experimentId } = useAppExperiment()
+    it('should take the name from the platform once an id-only binding resolves', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      const { experimentName } = useAppExperiment()
 
-      set(makeExperiment({ id: 1, name: 'First' }))
-      set(makeExperiment({ id: 2, name: 'Second' }))
+      const pending = store.selectById(8)
+      fetch.resolveWith(makeExperiment({ id: 8, name: 'Hexokinase knockout run' }))
+      await pending
 
-      expect(experimentName.value).toBe('Second')
-      expect(experimentId.value).toBe(2)
+      expect(experimentName.value).toBe('Hexokinase knockout run')
     })
-  })
 
-  describe('clear', () => {
-    it('should reset experimentName and experimentId to initial values', () => {
-      const { set, clear, experimentName, experimentId } = useAppExperiment()
+    it('should surface the store error when resolution fails', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      const { error } = useAppExperiment()
 
-      set(makeExperiment({ id: 99, name: 'To Be Cleared' }))
-      clear()
+      const pending = store.selectById(8)
+      fetch.rejectWith(new Error('Experiment not found'))
+      await pending
 
-      expect(experimentName.value).toBeUndefined()
-      expect(experimentId.value).toBeNull()
+      expect(error.value).toBe('Experiment not found')
     })
 
-    it('should reset experimentStatus in provided state', () => {
-      const { set, clear } = useAppExperiment()
+    it('should expose no name after a failed resolve, keeping the bound id', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      const { experimentName, experimentCode, experimentId } = useAppExperiment()
 
-      set(makeExperiment({ status: 'ongoing' }))
-      clear()
+      const pending = store.selectById(8)
+      fetch.rejectWith(new Error('Experiment not found'))
+      await pending
 
-      expect(getState().experimentStatus.value).toBeUndefined()
+      expect(experimentName.value).toBeUndefined()
+      expect(experimentCode.value).toBeUndefined()
+      expect(experimentId.value).toBe(8)
     })
   })
 
-  describe('returned refs are readonly', () => {
-    it('should expose experimentName as a readonly ref', () => {
+  describe('returned refs are read-only projections of the store', () => {
+    it('should expose experimentName as undefined with nothing selected', () => {
       const { experimentName } = useAppExperiment()
-      // Readonly refs still have a .value property for reading
       expect(experimentName.value).toBeUndefined()
     })
 
-    it('should expose experimentId as a readonly ref', () => {
+    it('should expose experimentId as null with nothing selected', () => {
       const { experimentId } = useAppExperiment()
       expect(experimentId.value).toBeNull()
     })
@@ -210,48 +281,75 @@ describe('useAppExperiment', () => {
   })
 
   // -------------------------------------------------------------------------
-  // handleSelect
+  // onSelect — fired by the store adopting an experiment, not by the shell
   // -------------------------------------------------------------------------
 
-  describe('handleSelect', () => {
-    it('should call onSelect callback with the experiment', () => {
+  describe('onSelect', () => {
+    it('should call onSelect when the store adopts an experiment', async () => {
       const onSelect = vi.fn()
       useAppExperiment({ onSelect })
-      const state = getState()
-      const experiment = makeExperiment()
 
-      state.handleSelect(experiment)
+      useExperimentStore().select(makeExperiment())
+      await nextTick()
 
       expect(onSelect).toHaveBeenCalledOnce()
-      expect(onSelect).toHaveBeenCalledWith(experiment)
     })
 
-    it('should set experimentId and experimentName via handleSelect', () => {
-      const { experimentId, experimentName } = useAppExperiment()
-      const state = getState()
+    it('should pass the platform record through unchanged', async () => {
+      const onSelect = vi.fn()
+      useAppExperiment({ onSelect })
       const experiment = makeExperiment({ id: 5, name: 'Selected Exp' })
 
-      state.handleSelect(experiment)
+      useExperimentStore().select(experiment)
+      await nextTick()
 
-      expect(experimentId.value).toBe(5)
-      expect(experimentName.value).toBe('Selected Exp')
+      expect(onSelect).toHaveBeenCalledWith(experiment)
     })
 
-    it('should close the modal after selection', () => {
-      useAppExperiment()
-      const state = getState()
+    it('should call onSelect when an id-only binding resolves', async () => {
+      const fetch = stubExperimentFetch()
+      const onSelect = vi.fn()
+      const store = useExperimentStore()
+      useAppExperiment({ onSelect })
 
-      state.openModal()
-      state.handleSelect(makeExperiment())
+      const pending = store.selectById(8)
+      fetch.resolveWith(makeExperiment({ id: 8, name: 'Resolved run' }))
+      await pending
+      await nextTick()
 
-      expect(state.showModal.value).toBe(false)
+      expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({ name: 'Resolved run' }))
+    })
+
+    it('should not call onSelect when the store is cleared', async () => {
+      const onSelect = vi.fn()
+      const store = useExperimentStore()
+      useAppExperiment({ onSelect })
+
+      store.select(makeExperiment())
+      await nextTick()
+      onSelect.mockClear()
+
+      store.clear()
+      await nextTick()
+
+      expect(onSelect).not.toHaveBeenCalled()
+    })
+
+    it('should not call onSelect for an experiment already selected at setup', async () => {
+      const onSelect = vi.fn()
+      useExperimentStore().select(makeExperiment())
+
+      useAppExperiment({ onSelect })
+      await nextTick()
+
+      expect(onSelect).not.toHaveBeenCalled()
     })
 
-    it('should not throw when no onSelect callback is provided', () => {
+    it('should not throw when no onSelect callback is provided', async () => {
       useAppExperiment()
-      const state = getState()
 
-      expect(() => state.handleSelect(makeExperiment())).not.toThrow()
+      expect(() => useExperimentStore().select(makeExperiment())).not.toThrow()
+      await nextTick()
     })
   })
 
@@ -391,17 +489,36 @@ describe('useAppExperiment', () => {
   // -------------------------------------------------------------------------
 
   describe('handleDetach', () => {
-    it('should clear experiment state', () => {
-      const { set, experimentId, experimentName } = useAppExperiment()
+    it('should clear the shared store', () => {
+      const store = useExperimentStore()
+      const { experimentId, experimentName } = useAppExperiment()
       const state = getState()
 
-      set(makeExperiment({ id: 3, name: 'Detachable' }))
+      store.select(makeExperiment({ id: 3, name: 'Detachable' }))
       state.handleDetach()
 
+      expect(store.current).toBeNull()
+      expect(store.currentId).toBeNull()
       expect(experimentId.value).toBeNull()
       expect(experimentName.value).toBeUndefined()
     })
 
+    it('should clear a binding whose resolution failed', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      const { experimentId, error } = useAppExperiment()
+      const state = getState()
+
+      const pending = store.selectById(8)
+      fetch.rejectWith(new Error('Experiment not found'))
+      await pending
+
+      state.handleDetach()
+
+      expect(experimentId.value).toBeNull()
+      expect(error.value).toBeNull()
+    })
+
     it('should call onDetach callback', () => {
       const onDetach = vi.fn()
       useAppExperiment({ onDetach })
@@ -421,7 +538,7 @@ describe('useAppExperiment', () => {
 
     it('should call onDetach after clearing state', () => {
       const calls: string[] = []
-      const { set, experimentId } = useAppExperiment({
+      const { experimentId } = useAppExperiment({
         onDetach: () => {
           // By the time onDetach fires, experimentId should already be null
           calls.push(experimentId.value === null ? 'cleared' : 'not-cleared')
@@ -429,7 +546,7 @@ describe('useAppExperiment', () => {
       })
       const state = getState()
 
-      set(makeExperiment())
+      useExperimentStore().select(makeExperiment())
       state.handleDetach()
 
       expect(calls).toEqual(['cleared'])
@@ -462,19 +579,44 @@ describe('useAppExperiment', () => {
       expect(getState().showDetach.value).toBe(false)
     })
 
-    it('should be true after an experiment is set', () => {
-      const { set } = useAppExperiment()
+    it('should be true after an experiment is selected', () => {
+      useAppExperiment()
 
-      set(makeExperiment())
+      useExperimentStore().select(makeExperiment())
 
       expect(getState().showDetach.value).toBe(true)
     })
 
-    it('should revert to false after clear is called', () => {
-      const { set, clear } = useAppExperiment()
+    it('should be true while an id-only binding is still resolving', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      useAppExperiment()
+
+      const pending = store.selectById(8)
+      expect(getState().showDetach.value).toBe(true)
 
-      set(makeExperiment())
-      clear()
+      fetch.resolveWith(makeExperiment({ id: 8 }))
+      await pending
+    })
+
+    it('should stay true after a failed resolve so the user can detach', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      useAppExperiment()
+
+      const pending = store.selectById(8)
+      fetch.rejectWith(new Error('Experiment not found'))
+      await pending
+
+      expect(getState().showDetach.value).toBe(true)
+    })
+
+    it('should revert to false after the store is cleared', () => {
+      const store = useExperimentStore()
+      useAppExperiment()
+
+      store.select(makeExperiment())
+      store.clear()
 
       expect(getState().showDetach.value).toBe(false)
     })
@@ -558,10 +700,10 @@ describe('useAppExperiment', () => {
       const saveDisabled = ref(false)
       const saveDisabledMessage = ref<string | undefined>('Ready to save')
       const onSave = vi.fn().mockResolvedValue('Saved')
-      const { set } = useAppExperiment({ onSave, saveDisabled, saveDisabledMessage })
+      useAppExperiment({ onSave, saveDisabled, saveDisabledMessage })
       const state = getState()
 
-      set(makeExperiment({
+      useExperimentStore().select(makeExperiment({
         id: 12,
         name: 'Dose response',
         status: 'ongoing',
@@ -572,12 +714,14 @@ describe('useAppExperiment', () => {
         experimentName: 'Dose response',
         experimentCode: 'EXP-012',
         experimentStatus: 'ongoing',
+        isResolving: false,
         showSave: true,
         showDetach: true,
         saveDisabled: false,
         saveDisabledMessage: 'Ready to save',
         saveLoading: false,
       })
+      expect(state.popover.value.error).toBeUndefined()
 
       saveDisabled.value = true
       saveDisabledMessage.value = 'Locked'
@@ -590,6 +734,44 @@ describe('useAppExperiment', () => {
       expect(state.popover.value.saveSuccessMessage).toBe('Saved')
     })
 
+    it('marks the popover binding as resolving with no name to show', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      useAppExperiment()
+      const state = getState()
+
+      const pending = store.selectById(12)
+
+      expect(state.popover.value).toMatchObject({
+        experimentName: undefined,
+        experimentCode: undefined,
+        isResolving: true,
+        showDetach: true,
+      })
+      expect(state.popover.value.error).toBeUndefined()
+
+      fetch.resolveWith(makeExperiment({ id: 12 }))
+      await pending
+    })
+
+    it('puts the resolution failure on the popover binding and keeps detach', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      useAppExperiment()
+      const state = getState()
+
+      const pending = store.selectById(12)
+      fetch.rejectWith(new Error('Experiment not found'))
+      await pending
+
+      expect(state.popover.value).toMatchObject({
+        experimentName: undefined,
+        isResolving: false,
+        error: 'Experiment not found',
+        showDetach: true,
+      })
+    })
+
     it('exposes live ExperimentSelectorModal props from state and return value', () => {
       const appExperiment = useAppExperiment()
       const state = getState()
@@ -600,7 +782,7 @@ describe('useAppExperiment', () => {
       })
       expect(appExperiment.selectorModal.value).toEqual(state.selectorModal.value)
 
-      appExperiment.set(makeExperiment({ id: 77 }))
+      useExperimentStore().select(makeExperiment({ id: 77 }))
       state.openModal()
 
       expect(state.selectorModal.value).toEqual({
@@ -609,6 +791,19 @@ describe('useAppExperiment', () => {
       })
       expect(appExperiment.popover.value.experimentName).toBe('Test Experiment')
     })
+
+    it('keeps the selector bound to the id after a failed resolve', async () => {
+      const fetch = stubExperimentFetch()
+      const store = useExperimentStore()
+      useAppExperiment()
+      const state = getState()
+
+      const pending = store.selectById(77)
+      fetch.rejectWith(new Error('Experiment not found'))
+      await pending
+
+      expect(state.selectorModal.value.currentExperimentId).toBe(77)
+    })
   })
 
   // -------------------------------------------------------------------------
@@ -658,3 +853,47 @@ describe('useAppExperiment', () => {
     })
   })
 })
+
+describe('useAppExperiment browser storage isolation', () => {
+  function installLegacySelection() {
+    const storage: Record<string, string> = { 'mint-current-experiment-id': '42' }
+    vi.stubGlobal('localStorage', {
+      getItem: vi.fn((key: string) => storage[key] ?? null),
+      setItem: vi.fn((key: string, value: string) => { storage[key] = value }),
+      removeItem: vi.fn((key: string) => { delete storage[key] }),
+      clear: vi.fn(() => { for (const key of Object.keys(storage)) delete storage[key] }),
+    } as unknown as Storage)
+  }
+
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    pendingFetch = null
+    installLegacySelection()
+    vi.spyOn(axios.Axios.prototype, 'get').mockRejectedValue(new Error('Unexpected platform request'))
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  it('should ignore a legacy persisted id when nothing is selected', () => {
+    const { experimentId } = useAppExperiment()
+
+    expect(experimentId.value).toBeNull()
+  })
+
+  it('should not request an experiment during shell setup', () => {
+    useAppExperiment()
+
+    expect(axios.Axios.prototype.get).not.toHaveBeenCalled()
+  })
+
+  it('should leave an already-bound experiment alone', () => {
+    useExperimentStore().select(makeExperiment({ id: 7, name: 'Already chosen' }))
+
+    const { experimentName } = useAppExperiment()
+
+    expect(experimentName.value).toBe('Already chosen')
+  })
+})

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

@@ -56,7 +56,7 @@ describe('useAuth', () => {
         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 },
+        data: { id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true },
       })
 
       const { login } = useAuth()
@@ -162,7 +162,7 @@ describe('useAuth', () => {
         throw new Error(`Unexpected POST ${url}`)
       })
       mockedAxios.get.mockResolvedValue({
-        data: { id: '1', username: 'test', shortname: null, email: null, role: 'user', is_active: true },
+        data: { id: 1, username: 'test', shortname: null, email: null, role: 'user', is_active: true },
       })
 
       const authA = useAuth()

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

@@ -1,4 +1,4 @@
-import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest'
+import { beforeEach, afterEach, describe, expect, expectTypeOf, it, vi } from 'vitest'
 
 const unmountedCallbacks: Array<() => void> = []
 
@@ -39,6 +39,10 @@ function sendThemeMessage(origin: string, theme: 'light' | 'dark' | 'system'): v
 }
 
 describe('usePlatformContext', () => {
+  it('uses integer IDs for injected users', () => {
+    expectTypeOf<NonNullable<PlatformContext['user']>['id']>().toEqualTypeOf<number>()
+  })
+
   beforeEach(() => {
     unmountedCallbacks.length = 0
     messageHandler = null