@morscherlab/mint-sdk 1.0.0-alpha.2

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

@@ -0,0 +1,560 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { ref, computed } from 'vue'
+
+// Capture side-effect callbacks so tests can invoke them directly
+let capturedScopeDispose: (() => void) | null = null
+let capturedProvideKey: symbol | null = null
+let capturedProvideValue: unknown = null
+
+vi.mock('vue', async () => {
+  const actual = await vi.importActual('vue')
+  return {
+    ...actual,
+    provide: vi.fn((key: symbol, value: unknown) => {
+      capturedProvideKey = key
+      capturedProvideValue = value
+    }),
+    onScopeDispose: vi.fn((cb: () => void) => {
+      capturedScopeDispose = cb
+    }),
+  }
+})
+
+import { useAppExperiment, APP_EXPERIMENT_KEY } from '../../composables/useAppExperiment'
+import type { AppExperimentState } from '../../composables/useAppExperiment'
+import type { ExperimentSummary } from '../../types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeExperiment(overrides: Partial<ExperimentSummary> = {}): ExperimentSummary {
+  return {
+    id: 42,
+    name: 'Test Experiment',
+    status: 'planned',
+    experiment_type: 'default',
+    created_at: '2025-01-01T00:00:00Z',
+    updated_at: '2025-01-01T00:00:00Z',
+    has_design_data: false,
+    ...overrides,
+  }
+}
+
+function getState(): AppExperimentState {
+  return capturedProvideValue as AppExperimentState
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('useAppExperiment', () => {
+  beforeEach(() => {
+    capturedScopeDispose = null
+    capturedProvideKey = null
+    capturedProvideValue = null
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  // -------------------------------------------------------------------------
+  // provide()
+  // -------------------------------------------------------------------------
+
+  describe('provide', () => {
+    it('should call provide with APP_EXPERIMENT_KEY', () => {
+      useAppExperiment()
+      expect(capturedProvideKey).toBe(APP_EXPERIMENT_KEY)
+    })
+
+    it('should provide a non-null state object', () => {
+      useAppExperiment()
+      expect(capturedProvideValue).toBeTruthy()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // set() and clear()
+  // -------------------------------------------------------------------------
+
+  describe('set', () => {
+    it('should update experimentName and experimentId on set', () => {
+      const { set, experimentName, experimentId } = useAppExperiment()
+      const experiment = makeExperiment({ id: 7, name: 'Alpha Run' })
+
+      set(experiment)
+
+      expect(experimentName.value).toBe('Alpha Run')
+      expect(experimentId.value).toBe(7)
+    })
+
+    it('should update experimentStatus in provided state', () => {
+      const { set } = useAppExperiment()
+      const experiment = makeExperiment({ status: 'completed' })
+
+      set(experiment)
+
+      expect(getState().experimentStatus.value).toBe('completed')
+    })
+
+    it('should overwrite previously set values', () => {
+      const { set, experimentName, experimentId } = useAppExperiment()
+
+      set(makeExperiment({ id: 1, name: 'First' }))
+      set(makeExperiment({ id: 2, name: 'Second' }))
+
+      expect(experimentName.value).toBe('Second')
+      expect(experimentId.value).toBe(2)
+    })
+  })
+
+  describe('clear', () => {
+    it('should reset experimentName and experimentId to initial values', () => {
+      const { set, clear, experimentName, experimentId } = useAppExperiment()
+
+      set(makeExperiment({ id: 99, name: 'To Be Cleared' }))
+      clear()
+
+      expect(experimentName.value).toBeUndefined()
+      expect(experimentId.value).toBeNull()
+    })
+
+    it('should reset experimentStatus in provided state', () => {
+      const { set, clear } = useAppExperiment()
+
+      set(makeExperiment({ status: 'ongoing' }))
+      clear()
+
+      expect(getState().experimentStatus.value).toBeUndefined()
+    })
+  })
+
+  describe('returned refs are readonly', () => {
+    it('should expose experimentName as a readonly ref', () => {
+      const { experimentName } = useAppExperiment()
+      // Readonly refs still have a .value property for reading
+      expect(experimentName.value).toBeUndefined()
+    })
+
+    it('should expose experimentId as a readonly ref', () => {
+      const { experimentId } = useAppExperiment()
+      expect(experimentId.value).toBeNull()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // openModal / closeModal
+  // -------------------------------------------------------------------------
+
+  describe('openModal and closeModal', () => {
+    it('should set showModal to true when openModal is called', () => {
+      useAppExperiment()
+      const state = getState()
+
+      expect(state.showModal.value).toBe(false)
+      state.openModal()
+      expect(state.showModal.value).toBe(true)
+    })
+
+    it('should set showModal to false when closeModal is called', () => {
+      useAppExperiment()
+      const state = getState()
+
+      state.openModal()
+      state.closeModal()
+      expect(state.showModal.value).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // handleSelect
+  // -------------------------------------------------------------------------
+
+  describe('handleSelect', () => {
+    it('should call onSelect callback with the experiment', () => {
+      const onSelect = vi.fn()
+      useAppExperiment({ onSelect })
+      const state = getState()
+      const experiment = makeExperiment()
+
+      state.handleSelect(experiment)
+
+      expect(onSelect).toHaveBeenCalledOnce()
+      expect(onSelect).toHaveBeenCalledWith(experiment)
+    })
+
+    it('should set experimentId and experimentName via handleSelect', () => {
+      const { experimentId, experimentName } = useAppExperiment()
+      const state = getState()
+      const experiment = makeExperiment({ id: 5, name: 'Selected Exp' })
+
+      state.handleSelect(experiment)
+
+      expect(experimentId.value).toBe(5)
+      expect(experimentName.value).toBe('Selected Exp')
+    })
+
+    it('should close the modal after selection', () => {
+      useAppExperiment()
+      const state = getState()
+
+      state.openModal()
+      state.handleSelect(makeExperiment())
+
+      expect(state.showModal.value).toBe(false)
+    })
+
+    it('should not throw when no onSelect callback is provided', () => {
+      useAppExperiment()
+      const state = getState()
+
+      expect(() => state.handleSelect(makeExperiment())).not.toThrow()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // handleSave
+  // -------------------------------------------------------------------------
+
+  describe('handleSave', () => {
+    it('should call onSave when invoked', async () => {
+      const onSave = vi.fn().mockResolvedValue(null)
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+
+      expect(onSave).toHaveBeenCalledOnce()
+    })
+
+    it('should set saveSuccessMessage when onSave returns a string', async () => {
+      const onSave = vi.fn().mockResolvedValue('Saved successfully!')
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+
+      expect(state.saveSuccessMessage.value).toBe('Saved successfully!')
+    })
+
+    it('should auto-clear saveSuccessMessage after 3 seconds', async () => {
+      const onSave = vi.fn().mockResolvedValue('Done')
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+      expect(state.saveSuccessMessage.value).toBe('Done')
+
+      vi.advanceTimersByTime(3000)
+      expect(state.saveSuccessMessage.value).toBeUndefined()
+    })
+
+    it('should not clear saveSuccessMessage before 3 seconds have elapsed', async () => {
+      const onSave = vi.fn().mockResolvedValue('Pending')
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+      vi.advanceTimersByTime(2999)
+
+      expect(state.saveSuccessMessage.value).toBe('Pending')
+    })
+
+    it('should reset the 3-second timer on a subsequent successful save', async () => {
+      const onSave = vi.fn().mockResolvedValue('Resaved')
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+      vi.advanceTimersByTime(2000)
+
+      await state.handleSave()
+      vi.advanceTimersByTime(2000)
+      // Only 2s have passed since the second save — message should still be set
+      expect(state.saveSuccessMessage.value).toBe('Resaved')
+
+      vi.advanceTimersByTime(1000)
+      expect(state.saveSuccessMessage.value).toBeUndefined()
+    })
+
+    it('should manage saveLoading: true during save, false after', async () => {
+      let resolveSave!: (v: string | null) => void
+      const onSave = vi.fn(
+        () => new Promise<string | null>((resolve) => { resolveSave = resolve })
+      )
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      const savePromise = state.handleSave()
+      expect(state.saveLoading.value).toBe(true)
+
+      resolveSave(null)
+      await savePromise
+      expect(state.saveLoading.value).toBe(false)
+    })
+
+    it('should set saveLoading to false even when onSave rejects', async () => {
+      const onSave = vi.fn().mockRejectedValue(new Error('network error'))
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave().catch(() => {})
+
+      expect(state.saveLoading.value).toBe(false)
+    })
+
+    it('should be a no-op (not call onSave) when saveLoading is already true', async () => {
+      let resolveSave!: (v: string | null) => void
+      const onSave = vi.fn(
+        () => new Promise<string | null>((resolve) => { resolveSave = resolve })
+      )
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      // Start first save but do not await it yet
+      const first = state.handleSave()
+
+      // Attempt second save while first is in-flight
+      await state.handleSave()
+
+      resolveSave(null)
+      await first
+
+      expect(onSave).toHaveBeenCalledTimes(1)
+    })
+
+    it('should not call onSave and return immediately when no onSave option is provided', async () => {
+      useAppExperiment()
+      const state = getState()
+
+      // Should not throw and saveLoading should remain false
+      await state.handleSave()
+      expect(state.saveLoading.value).toBe(false)
+    })
+
+    it('should not set saveSuccessMessage when onSave returns null', async () => {
+      const onSave = vi.fn().mockResolvedValue(null)
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+
+      expect(state.saveSuccessMessage.value).toBeUndefined()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // handleDetach
+  // -------------------------------------------------------------------------
+
+  describe('handleDetach', () => {
+    it('should clear experiment state', () => {
+      const { set, experimentId, experimentName } = useAppExperiment()
+      const state = getState()
+
+      set(makeExperiment({ id: 3, name: 'Detachable' }))
+      state.handleDetach()
+
+      expect(experimentId.value).toBeNull()
+      expect(experimentName.value).toBeUndefined()
+    })
+
+    it('should call onDetach callback', () => {
+      const onDetach = vi.fn()
+      useAppExperiment({ onDetach })
+      const state = getState()
+
+      state.handleDetach()
+
+      expect(onDetach).toHaveBeenCalledOnce()
+    })
+
+    it('should not throw when no onDetach callback is provided', () => {
+      useAppExperiment()
+      const state = getState()
+
+      expect(() => state.handleDetach()).not.toThrow()
+    })
+
+    it('should call onDetach after clearing state', () => {
+      const calls: string[] = []
+      const { set, experimentId } = useAppExperiment({
+        onDetach: () => {
+          // By the time onDetach fires, experimentId should already be null
+          calls.push(experimentId.value === null ? 'cleared' : 'not-cleared')
+        },
+      })
+      const state = getState()
+
+      set(makeExperiment())
+      state.handleDetach()
+
+      expect(calls).toEqual(['cleared'])
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // showSave
+  // -------------------------------------------------------------------------
+
+  describe('showSave', () => {
+    it('should be true when onSave is provided', () => {
+      useAppExperiment({ onSave: vi.fn().mockResolvedValue(null) })
+      expect(getState().showSave.value).toBe(true)
+    })
+
+    it('should be false when onSave is not provided', () => {
+      useAppExperiment()
+      expect(getState().showSave.value).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // showDetach
+  // -------------------------------------------------------------------------
+
+  describe('showDetach', () => {
+    it('should be false initially (no experiment set)', () => {
+      useAppExperiment()
+      expect(getState().showDetach.value).toBe(false)
+    })
+
+    it('should be true after an experiment is set', () => {
+      const { set } = useAppExperiment()
+
+      set(makeExperiment())
+
+      expect(getState().showDetach.value).toBe(true)
+    })
+
+    it('should revert to false after clear is called', () => {
+      const { set, clear } = useAppExperiment()
+
+      set(makeExperiment())
+      clear()
+
+      expect(getState().showDetach.value).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // saveDisabled
+  // -------------------------------------------------------------------------
+
+  describe('saveDisabled', () => {
+    it('should be false by default when no saveDisabled option is provided', () => {
+      useAppExperiment()
+      expect(getState().saveDisabled.value).toBe(false)
+    })
+
+    it('should unwrap a raw Ref<boolean>', () => {
+      const flag = ref(true)
+      useAppExperiment({ saveDisabled: flag })
+
+      expect(getState().saveDisabled.value).toBe(true)
+
+      flag.value = false
+      expect(getState().saveDisabled.value).toBe(false)
+    })
+
+    it('should unwrap a ComputedRef<boolean>', () => {
+      const source = ref(false)
+      const flag = computed(() => source.value)
+      useAppExperiment({ saveDisabled: flag })
+
+      expect(getState().saveDisabled.value).toBe(false)
+
+      source.value = true
+      expect(getState().saveDisabled.value).toBe(true)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // saveDisabledMessage
+  // -------------------------------------------------------------------------
+
+  describe('saveDisabledMessage', () => {
+    it('should be undefined when no saveDisabledMessage option is provided', () => {
+      useAppExperiment()
+      expect(getState().saveDisabledMessage.value).toBeUndefined()
+    })
+
+    it('should unwrap a plain string', () => {
+      useAppExperiment({ saveDisabledMessage: 'Cannot save right now' })
+      expect(getState().saveDisabledMessage.value).toBe('Cannot save right now')
+    })
+
+    it('should unwrap a Ref<string | undefined>', () => {
+      const msg = ref<string | undefined>('Initial message')
+      useAppExperiment({ saveDisabledMessage: msg })
+
+      expect(getState().saveDisabledMessage.value).toBe('Initial message')
+
+      msg.value = undefined
+      expect(getState().saveDisabledMessage.value).toBeUndefined()
+    })
+
+    it('should unwrap a ComputedRef<string | undefined>', () => {
+      const active = ref(true)
+      const msg = computed(() => (active.value ? 'Disabled because active' : undefined))
+      useAppExperiment({ saveDisabledMessage: msg })
+
+      expect(getState().saveDisabledMessage.value).toBe('Disabled because active')
+
+      active.value = false
+      expect(getState().saveDisabledMessage.value).toBeUndefined()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // Timer cleanup via onScopeDispose
+  // -------------------------------------------------------------------------
+
+  describe('onScopeDispose cleanup', () => {
+    it('should register an onScopeDispose callback', () => {
+      useAppExperiment()
+      expect(capturedScopeDispose).toBeTypeOf('function')
+    })
+
+    it('should clear the success timer when the scope is disposed', async () => {
+      const clearTimeoutSpy = vi.spyOn(globalThis, 'clearTimeout')
+      const onSave = vi.fn().mockResolvedValue('Saved')
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+      // Timer is active — disposing the scope should cancel it
+      capturedScopeDispose!()
+
+      expect(clearTimeoutSpy).toHaveBeenCalled()
+    })
+
+    it('should not call clearTimeout if no timer is active at disposal time', () => {
+      const clearTimeoutSpy = vi.spyOn(globalThis, 'clearTimeout')
+      useAppExperiment()
+
+      // Dispose without ever triggering a save
+      capturedScopeDispose!()
+
+      expect(clearTimeoutSpy).not.toHaveBeenCalled()
+    })
+
+    it('should not clear saveSuccessMessage after disposal if timer was cancelled', async () => {
+      const onSave = vi.fn().mockResolvedValue('Will be cancelled')
+      useAppExperiment({ onSave })
+      const state = getState()
+
+      await state.handleSave()
+      capturedScopeDispose!()
+
+      // Advancing time past 3s should NOT clear message since timer was cancelled
+      vi.advanceTimersByTime(3000)
+      expect(state.saveSuccessMessage.value).toBe('Will be cancelled')
+    })
+  })
+})