@morscherlab/mint-sdk 1.0.0-alpha.2

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

@@ -0,0 +1,127 @@
+/**
+ * Tests for useExperimentData.
+ *
+ * Covers the derived computeds plugins rely on when rendering plugin
+ * data that was saved via the platform's /api/experiments/{id}/data
+ * endpoint:
+ *
+ * - tree_data / treeData snake-or-camel case handling
+ * - table_data / tableData
+ * - summary_data validation (must have a `metadata` key)
+ * - load / refresh / error paths
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import axios, { type AxiosRequestConfig } from 'axios'
+
+import { useExperimentData } from '../../composables/useExperimentData'
+
+let fakeResponse: unknown = null
+let fakeError: Error | null = null
+let recordedUrls: string[] = []
+
+describe('useExperimentData', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    fakeResponse = {}
+    fakeError = null
+    recordedUrls = []
+    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      if (fakeError) throw fakeError
+      return { data: fakeResponse }
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('fetch resolves data and flips isLoading', async () => {
+    fakeResponse = { tree_data: [{ id: 'a', label: 'A' }] }
+    const hook = useExperimentData()
+
+    expect(hook.isLoading.value).toBe(false)
+    const p = hook.fetch(42)
+    expect(hook.isLoading.value).toBe(true)
+    await p
+    expect(hook.isLoading.value).toBe(false)
+    expect(hook.data.value).toEqual({ tree_data: [{ id: 'a', label: 'A' }] })
+    expect(recordedUrls[0]).toBe('/experiments/42/data')
+  })
+
+  it('exposes tree_data via treeData regardless of snake vs camel', async () => {
+    fakeResponse = { tree_data: [{ id: '1' }] }
+    const hook1 = useExperimentData()
+    await hook1.fetch(1)
+    expect(hook1.treeData.value).toEqual([{ id: '1' }])
+
+    fakeResponse = { treeData: [{ id: '2' }] }
+    const hook2 = useExperimentData()
+    await hook2.fetch(2)
+    expect(hook2.treeData.value).toEqual([{ id: '2' }])
+  })
+
+  it('tableData falls back to empty array when absent', async () => {
+    fakeResponse = {}
+    const hook = useExperimentData()
+    await hook.fetch(1)
+    expect(hook.tableData.value).toEqual([])
+  })
+
+  it('summaryData requires a metadata key', async () => {
+    fakeResponse = { summary_data: { metadata: { n: 1 }, sections: [] } }
+    const hook = useExperimentData()
+    await hook.fetch(1)
+    expect(hook.summaryData.value).toEqual({
+      metadata: { n: 1 },
+      sections: [],
+    })
+
+    // Invalid summary shape -> returns null
+    fakeResponse = { summary_data: { notmeta: true } }
+    const hook2 = useExperimentData()
+    await hook2.fetch(2)
+    expect(hook2.summaryData.value).toBeNull()
+  })
+
+  it('refresh reuses the last experimentId', async () => {
+    fakeResponse = { tree_data: [] }
+    const hook = useExperimentData()
+    await hook.fetch(99)
+    recordedUrls.length = 0
+
+    await hook.refresh()
+    expect(recordedUrls).toEqual(['/experiments/99/data'])
+  })
+
+  it('refresh before any fetch is a noop', async () => {
+    const hook = useExperimentData()
+    await hook.refresh()
+    expect(recordedUrls).toEqual([])
+  })
+
+  it('sets error and clears data on network failure', async () => {
+    fakeError = new Error('boom')
+    const hook = useExperimentData()
+    await hook.fetch(1)
+    expect(hook.error.value).toBe('boom')
+    expect(hook.data.value).toBeNull()
+    expect(hook.isLoading.value).toBe(false)
+  })
+
+  it('apiBaseUrl option is honoured', async () => {
+    fakeResponse = {}
+    const hook = useExperimentData({ apiBaseUrl: '/api/plugin' })
+    await hook.fetch(5)
+    // useApi attaches baseURL to the request config; the mocked axios
+    // call records it in recordedUrls as the relative URL only, so we
+    // can't observe baseURL directly here — assert the URL shape.
+    expect(recordedUrls[0]).toBe('/experiments/5/data')
+  })
+})

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

@@ -0,0 +1,347 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ---------------------------------------------------------------------------
+// Mock useApi — intercepts all HTTP calls
+// ---------------------------------------------------------------------------
+
+const mockGet = vi.fn()
+const mockPut = vi.fn()
+const mockDelete = vi.fn()
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: () => ({
+    get: mockGet,
+    put: mockPut,
+    delete: mockDelete,
+  }),
+}))
+
+import { useExperimentSave } from '../../composables/useExperimentSave'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function setup(options?: Parameters<typeof useExperimentSave>[0]) {
+  return useExperimentSave(options)
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('useExperimentSave', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({})
+    mockPut.mockResolvedValue({})
+    mockDelete.mockResolvedValue({})
+  })
+
+  // -------------------------------------------------------------------------
+  // saveDesign
+  // -------------------------------------------------------------------------
+
+  describe('saveDesign', () => {
+    it('should call PUT /experiments/{id}/data with correct body', async () => {
+      const { saveDesign } = setup({ pluginId: 'my-plugin', schemaVersion: '2.0' })
+
+      await saveDesign(42, { layout: 'grid' })
+
+      expect(mockPut).toHaveBeenCalledOnce()
+      expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
+        plugin_id: 'my-plugin',
+        data: { layout: 'grid' },
+        schema_version: '2.0',
+      })
+    })
+
+    it('should use default schema_version "1.0" when not provided', async () => {
+      const { saveDesign } = setup({ pluginId: 'p1' })
+
+      await saveDesign(1, { x: 1 })
+
+      const body = mockPut.mock.calls[0][1]
+      expect(body.schema_version).toBe('1.0')
+    })
+
+    it('should return true on success', async () => {
+      const { saveDesign } = setup({ pluginId: 'p1' })
+      const ok = await saveDesign(1, { x: 1 })
+      expect(ok).toBe(true)
+    })
+
+    it('should return false on error', async () => {
+      mockPut.mockRejectedValueOnce(new Error('Network error'))
+      const { saveDesign } = setup({ pluginId: 'p1' })
+      const ok = await saveDesign(1, { x: 1 })
+      expect(ok).toBe(false)
+    })
+
+    it('should set isSaving during the call', async () => {
+      let resolvePut!: (v: unknown) => void
+      mockPut.mockImplementationOnce(() => new Promise((r) => { resolvePut = r }))
+
+      const { saveDesign, isSaving } = setup({ pluginId: 'p1' })
+      expect(isSaving.value).toBe(false)
+
+      const promise = saveDesign(1, { x: 1 })
+      expect(isSaving.value).toBe(true)
+
+      resolvePut({})
+      await promise
+      expect(isSaving.value).toBe(false)
+    })
+
+    it('should set error on failure', async () => {
+      mockPut.mockRejectedValueOnce(new Error('Bad request'))
+      const { saveDesign, error } = setup({ pluginId: 'p1' })
+
+      await saveDesign(1, { x: 1 })
+
+      expect(error.value).toBe('Bad request')
+    })
+
+    it('should clear previous error on success', async () => {
+      mockPut.mockRejectedValueOnce(new Error('First fail'))
+      const { saveDesign, error } = setup({ pluginId: 'p1' })
+
+      await saveDesign(1, { x: 1 })
+      expect(error.value).toBe('First fail')
+
+      mockPut.mockResolvedValueOnce({})
+      await saveDesign(1, { x: 1 })
+      expect(error.value).toBeNull()
+    })
+
+    it('should update lastSavedAt on success', async () => {
+      const { saveDesign, lastSavedAt } = setup({ pluginId: 'p1' })
+      expect(lastSavedAt.value).toBeNull()
+
+      await saveDesign(1, { x: 1 })
+
+      expect(lastSavedAt.value).toBeInstanceOf(Date)
+    })
+
+    it('should not update lastSavedAt on failure', async () => {
+      mockPut.mockRejectedValueOnce(new Error('fail'))
+      const { saveDesign, lastSavedAt } = setup({ pluginId: 'p1' })
+
+      await saveDesign(1, { x: 1 })
+
+      expect(lastSavedAt.value).toBeNull()
+    })
+
+    it('should require pluginId', async () => {
+      const { saveDesign } = setup()
+      const ok = await saveDesign(1, { x: 1 })
+      expect(ok).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // saveAnalysis
+  // -------------------------------------------------------------------------
+
+  describe('saveAnalysis', () => {
+    it('should call PUT /experiments/{id}/results/{pluginId}', async () => {
+      const { saveAnalysis } = setup({ pluginId: 'my-plugin' })
+
+      await saveAnalysis(42, { score: 0.95 })
+
+      expect(mockPut).toHaveBeenCalledOnce()
+      expect(mockPut).toHaveBeenCalledWith(
+        '/experiments/42/results/my-plugin',
+        { result: { score: 0.95 } },
+      )
+    })
+
+    it('should return true on success', async () => {
+      const { saveAnalysis } = setup({ pluginId: 'p1' })
+      const ok = await saveAnalysis(1, { score: 1 })
+      expect(ok).toBe(true)
+    })
+
+    it('should return false on error', async () => {
+      mockPut.mockRejectedValueOnce(new Error('fail'))
+      const { saveAnalysis } = setup({ pluginId: 'p1' })
+      const ok = await saveAnalysis(1, { score: 1 })
+      expect(ok).toBe(false)
+    })
+
+    it('should require pluginId', async () => {
+      const { saveAnalysis } = setup()
+      const ok = await saveAnalysis(1, { score: 1 })
+      expect(ok).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // save (combined)
+  // -------------------------------------------------------------------------
+
+  describe('save', () => {
+    it('should call both endpoints when design and analysis provided', async () => {
+      const { save } = setup({ pluginId: 'p1', schemaVersion: '2.0' })
+
+      const ok = await save(1, {
+        design: { layout: 'grid' },
+        analysis: { score: 0.9 },
+      })
+
+      expect(ok).toBe(true)
+      expect(mockPut).toHaveBeenCalledTimes(2)
+    })
+
+    it('should call only design endpoint when analysis is omitted', async () => {
+      const { save } = setup({ pluginId: 'p1' })
+
+      await save(1, { design: { x: 1 } })
+
+      expect(mockPut).toHaveBeenCalledTimes(1)
+      expect(mockPut.mock.calls[0][0]).toBe('/experiments/1/data')
+    })
+
+    it('should call only analysis endpoint when design is omitted', async () => {
+      const { save } = setup({ pluginId: 'p1' })
+
+      await save(1, { analysis: { score: 1 } })
+
+      expect(mockPut).toHaveBeenCalledTimes(1)
+      expect(mockPut.mock.calls[0][0]).toBe('/experiments/1/results/p1')
+    })
+
+    it('should return false if either call fails', async () => {
+      mockPut
+        .mockResolvedValueOnce({})          // design succeeds
+        .mockRejectedValueOnce(new Error()) // analysis fails
+
+      const { save } = setup({ pluginId: 'p1' })
+      const ok = await save(1, {
+        design: { x: 1 },
+        analysis: { y: 2 },
+      })
+
+      expect(ok).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // loadDesign
+  // -------------------------------------------------------------------------
+
+  describe('loadDesign', () => {
+    it('should call GET /experiments/{id}/data', async () => {
+      mockGet.mockResolvedValueOnce({ data: { key: 'value' } })
+      const { loadDesign } = setup()
+
+      await loadDesign(42)
+
+      expect(mockGet).toHaveBeenCalledOnce()
+      expect(mockGet).toHaveBeenCalledWith('/experiments/42/data')
+    })
+
+    it('should return the data on success', async () => {
+      mockGet.mockResolvedValueOnce({ data: { key: 'value' } })
+      const { loadDesign } = setup()
+
+      const result = await loadDesign(1)
+      expect(result).toEqual({ data: { key: 'value' } })
+    })
+
+    it('should return null on error', async () => {
+      mockGet.mockRejectedValueOnce(new Error('not found'))
+      const { loadDesign } = setup()
+
+      const result = await loadDesign(999)
+      expect(result).toBeNull()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // loadAnalysis
+  // -------------------------------------------------------------------------
+
+  describe('loadAnalysis', () => {
+    it('should call GET /experiments/{id}/results/{pluginId}', async () => {
+      mockGet.mockResolvedValueOnce({ result: { score: 1 } })
+      const { loadAnalysis } = setup({ pluginId: 'p1' })
+
+      await loadAnalysis(42)
+
+      expect(mockGet).toHaveBeenCalledOnce()
+      expect(mockGet).toHaveBeenCalledWith('/experiments/42/results/p1')
+    })
+
+    it('should return the result on success', async () => {
+      mockGet.mockResolvedValueOnce({ result: { score: 0.5 } })
+      const { loadAnalysis } = setup({ pluginId: 'p1' })
+
+      const result = await loadAnalysis(1)
+      expect(result).toEqual({ result: { score: 0.5 } })
+    })
+
+    it('should return null on error', async () => {
+      mockGet.mockRejectedValueOnce(new Error('not found'))
+      const { loadAnalysis } = setup({ pluginId: 'p1' })
+
+      const result = await loadAnalysis(999)
+      expect(result).toBeNull()
+    })
+
+    it('should return null when pluginId not set', async () => {
+      const { loadAnalysis } = setup()
+      const result = await loadAnalysis(1)
+      expect(result).toBeNull()
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // deleteDesign
+  // -------------------------------------------------------------------------
+
+  describe('deleteDesign', () => {
+    it('should call DELETE /experiments/{id}/data', async () => {
+      const { deleteDesign } = setup()
+
+      await deleteDesign(42)
+
+      expect(mockDelete).toHaveBeenCalledOnce()
+      expect(mockDelete).toHaveBeenCalledWith('/experiments/42/data')
+    })
+
+    it('should return true on success', async () => {
+      const { deleteDesign } = setup()
+      const ok = await deleteDesign(1)
+      expect(ok).toBe(true)
+    })
+
+    it('should return false on error', async () => {
+      mockDelete.mockRejectedValueOnce(new Error('fail'))
+      const { deleteDesign } = setup()
+      const ok = await deleteDesign(1)
+      expect(ok).toBe(false)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // deleteAnalysis
+  // -------------------------------------------------------------------------
+
+  describe('deleteAnalysis', () => {
+    it('should call DELETE /experiments/{id}/results/{pluginId}', async () => {
+      const { deleteAnalysis } = setup({ pluginId: 'p1' })
+
+      await deleteAnalysis(42)
+
+      expect(mockDelete).toHaveBeenCalledOnce()
+      expect(mockDelete).toHaveBeenCalledWith('/experiments/42/results/p1')
+    })
+
+    it('should return false when pluginId not set', async () => {
+      const { deleteAnalysis } = setup()
+      const ok = await deleteAnalysis(1)
+      expect(ok).toBe(false)
+    })
+  })
+})

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

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi } from 'vitest'
+
+// Mock vue lifecycle hooks since we're not in a component
+vi.mock('vue', async () => {
+  const actual = await vi.importActual('vue')
+  return {
+    ...actual,
+    onMounted: vi.fn(),
+    onUnmounted: vi.fn(),
+  }
+})
+
+import { useForm } from '../../composables/useForm'
+
+describe('useForm', () => {
+  describe('initialization', () => {
+    it('should initialize with provided values', () => {
+      const { data } = useForm({ name: '', email: '' })
+      expect(data.name).toBe('')
+      expect(data.email).toBe('')
+    })
+
+    it('should start with no errors', () => {
+      const { errors } = useForm({ name: '' })
+      expect(errors.name).toBeNull()
+    })
+
+    it('should start as not dirty', () => {
+      const { isDirty } = useForm({ name: '' })
+      expect(isDirty.value).toBe(false)
+    })
+  })
+
+  describe('validation - required', () => {
+    it('should fail for empty required field', () => {
+      const { validateField, errors } = useForm(
+        { name: '' },
+        { name: { required: true } }
+      )
+      const valid = validateField('name')
+      expect(valid).toBe(false)
+      expect(errors.name).toBe('This field is required')
+    })
+
+    it('should pass for filled required field', () => {
+      const { data, validateField, errors } = useForm(
+        { name: '' },
+        { name: { required: true } }
+      )
+      data.name = 'Alice'
+      const valid = validateField('name')
+      expect(valid).toBe(true)
+      expect(errors.name).toBeNull()
+    })
+
+    it('should use custom required message', () => {
+      const { validateField, errors } = useForm(
+        { name: '' },
+        { name: { required: 'Name is required' } }
+      )
+      validateField('name')
+      expect(errors.name).toBe('Name is required')
+    })
+  })
+
+  describe('validation - email', () => {
+    it('should reject invalid email', () => {
+      const { data, validateField, errors } = useForm(
+        { email: '' },
+        { email: { email: true } }
+      )
+      data.email = 'notanemail'
+      const valid = validateField('email')
+      expect(valid).toBe(false)
+      expect(errors.email).toBe('Invalid email address')
+    })
+
+    it('should accept valid email', () => {
+      const { data, validateField, errors } = useForm(
+        { email: '' },
+        { email: { email: true } }
+      )
+      data.email = 'user@example.com'
+      const valid = validateField('email')
+      expect(valid).toBe(true)
+      expect(errors.email).toBeNull()
+    })
+  })
+
+  describe('validation - minLength', () => {
+    it('should reject short strings', () => {
+      const { data, validateField, errors } = useForm(
+        { password: '' },
+        { password: { minLength: 8 } }
+      )
+      data.password = 'abc'
+      const valid = validateField('password')
+      expect(valid).toBe(false)
+      expect(errors.password).toBe('Must be at least 8 characters')
+    })
+  })
+
+  describe('validation - pattern', () => {
+    it('should validate with regex', () => {
+      const { data, validateField, errors } = useForm(
+        { code: '' },
+        { code: { pattern: /^[A-Z]{3}$/ } }
+      )
+      data.code = 'ab'
+      expect(validateField('code')).toBe(false)
+      expect(errors.code).toBe('Invalid format')
+
+      data.code = 'ABC'
+      expect(validateField('code')).toBe(true)
+    })
+  })
+
+  describe('validation - custom', () => {
+    it('should support custom validator', () => {
+      const { data, validateField, errors } = useForm(
+        { password: '', confirm: '' },
+        {
+          confirm: {
+            custom: (value, formData) =>
+              value !== formData.password ? 'Passwords must match' : undefined,
+          },
+        }
+      )
+      data.password = 'secret123'
+      data.confirm = 'different'
+      expect(validateField('confirm')).toBe(false)
+      expect(errors.confirm).toBe('Passwords must match')
+
+      data.confirm = 'secret123'
+      expect(validateField('confirm')).toBe(true)
+    })
+  })
+
+  describe('validate (all fields)', () => {
+    it('should validate all fields at once', () => {
+      const { validate, errors } = useForm(
+        { name: '', email: '' },
+        { name: { required: true }, email: { required: true } }
+      )
+      const valid = validate()
+      expect(valid).toBe(false)
+      expect(errors.name).not.toBeNull()
+      expect(errors.email).not.toBeNull()
+    })
+  })
+
+  describe('setFieldValue', () => {
+    it('should update field value', () => {
+      const { data, setFieldValue } = useForm({ name: '' })
+      setFieldValue('name', 'Bob')
+      expect(data.name).toBe('Bob')
+    })
+  })
+
+  describe('reset', () => {
+    it('should reset to initial values', () => {
+      const { data, errors, touched, dirty, reset, setFieldTouched } = useForm(
+        { name: 'initial' },
+        { name: { required: true } }
+      )
+      data.name = 'changed'
+      setFieldTouched('name')
+      reset()
+      expect(data.name).toBe('initial')
+      expect(errors.name).toBeNull()
+      expect(touched.name).toBe(false)
+      expect(dirty.name).toBe(false)
+    })
+  })
+
+  describe('dirty tracking', () => {
+    it('should track dirty state on setFieldValue', () => {
+      const { setFieldValue } = useForm({ name: 'original' })
+      setFieldValue('name', 'changed')
+      // Note: dirty tracking happens via watch, which may be async in tests
+      // setFieldValue directly mutates data, watch triggers next tick
+    })
+  })
+
+  describe('handleSubmit', () => {
+    it('should call onSubmit when valid', async () => {
+      const onSubmit = vi.fn()
+      const { data, handleSubmit } = useForm({ name: 'Alice' })
+      const handler = handleSubmit(onSubmit)
+      await handler()
+      expect(onSubmit).toHaveBeenCalledWith(data)
+    })
+
+    it('should not call onSubmit when invalid', async () => {
+      const onSubmit = vi.fn()
+      const { handleSubmit } = useForm(
+        { name: '' },
+        { name: { required: true } }
+      )
+      const handler = handleSubmit(onSubmit)
+      await handler()
+      expect(onSubmit).not.toHaveBeenCalled()
+    })
+  })
+})