@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.1

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

@@ -1,183 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { createPinia } from 'pinia'
-import { computed, defineComponent, h, ref, nextTick } from 'vue'
-import { describe, expect, it, vi } from 'vitest'
-import AppLayout from '../../components/AppLayout.vue'
-import AppSidebar from '../../components/AppSidebar.vue'
-import DoseDesignWorkspaceView from '../../components/DoseDesignWorkspaceView.vue'
-
-vi.mock('../../composables/usePlatformContext', () => ({
-  usePlatformContext: vi.fn(() => ({
-    isIntegrated: computed(() => false),
-    context: ref({ isIntegrated: false, theme: 'system' }),
-    plugin: computed(() => undefined),
-    user: computed(() => undefined),
-    theme: computed(() => 'system' as const),
-    features: computed(() => undefined),
-    navigate: vi.fn(),
-    notify: vi.fn(),
-    sendToPlatform: vi.fn(),
-  })),
-}))
-
-vi.mock('../../composables/useTheme', () => ({
-  useTheme: vi.fn(() => ({
-    isDark: ref(false),
-    theme: ref('light'),
-    toggleTheme: vi.fn(),
-  })),
-}))
-
-const WellPlateStub = defineComponent({
-  name: 'WellPlate',
-  props: {
-    modelValue: { type: Array, default: () => [] },
-    format: { type: Number, default: 96 },
-    wells: { type: Object, default: undefined },
-    disabled: { type: Boolean, default: false },
-    size: { type: String, default: undefined },
-    selectionMode: { type: String, default: undefined },
-    heatmap: { type: Object, default: undefined },
-  },
-  emits: ['update:modelValue'],
-  template: '<button data-test="well-plate" @click="$emit(\'update:modelValue\', [\'B1\', \'B2\'])" />',
-})
-
-const DoseCalculatorStub = defineComponent({
-  name: 'DoseCalculator',
-  props: {
-    mode: { type: String, default: 'auto' },
-    targetWells: { type: Array, default: () => [] },
-    disabled: { type: Boolean, default: false },
-    molecularWeight: { type: Number, default: undefined },
-  },
-  template: '<div data-test="dose-calculator" />',
-})
-
-function mountWorkspace(
-  props: Record<string, unknown> = {},
-  slots: Record<string, unknown> = {},
-) {
-  return mount(DoseDesignWorkspaceView, {
-    props,
-    slots: slots as never,
-    global: {
-      plugins: [createPinia()],
-      stubs: {
-        WellPlate: WellPlateStub,
-        DoseCalculator: DoseCalculatorStub,
-        'router-link': {
-          template: '<a><slot /></a>',
-        },
-        BaseModal: {
-          template: '<div><slot /></div>',
-        },
-      },
-    },
-  })
-}
-
-describe('DoseDesignWorkspaceView', () => {
-  it('renders WellPlate and DoseCalculator from one dose-design model', async () => {
-    const wrapper = mountWorkspace({
-      modelValue: {
-        selectedWells: ['A1'],
-        plateFormat: 384,
-        doseMode: 'serial',
-        disabled: false,
-      },
-      doseDesignOptions: {
-        includeMolecularWeight: true,
-      },
-      wellPlateProps: {
-        size: 'lg',
-        selectionMode: 'single',
-        heatmap: { enabled: true },
-      },
-      doseCalculatorProps: {
-        disabled: true,
-      },
-    })
-
-    const wellPlate = wrapper.findComponent(WellPlateStub)
-    const doseCalculator = wrapper.findComponent(DoseCalculatorStub)
-
-    expect(wellPlate.props()).toMatchObject({
-      modelValue: ['A1'],
-      format: 384,
-      size: 'lg',
-      selectionMode: 'single',
-      heatmap: { enabled: true },
-    })
-    expect(doseCalculator.props()).toMatchObject({
-      mode: 'serial',
-      targetWells: ['A1'],
-      disabled: true,
-      molecularWeight: 300,
-    })
-
-    await wellPlate.trigger('click')
-    await nextTick()
-
-    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
-      selectedWells: ['B1', 'B2'],
-    })
-  })
-
-  it('uses custom generated component prop ids from doseDesignOptions', () => {
-    const wrapper = mountWorkspace({
-      doseDesignOptions: {
-        selectedWells: ['C1'],
-        componentProps: {
-          plateId: 'plateView',
-          doseId: 'doseTool',
-        },
-      },
-    })
-
-    expect(wrapper.findComponent(WellPlateStub).props('modelValue')).toEqual(['C1'])
-    expect(wrapper.findComponent(DoseCalculatorStub).props('targetWells')).toEqual(['C1'])
-  })
-
-  it('passes through sidebar chrome overrides', () => {
-    const wrapper = mountWorkspace({
-      sidebarVariant: 'default',
-      responsiveSidebar: false,
-      sidebarTitle: 'Dose Controls',
-      sidebarSubtitle: 'Plate setup',
-      sidebarBadge: 'ready',
-    })
-
-    expect(wrapper.findComponent(AppLayout).props('responsiveSidebar')).toBe(false)
-    expect(wrapper.findComponent(AppSidebar).props('title')).toBe('Dose Controls')
-    expect(wrapper.findComponent(AppSidebar).props('subtitle')).toBe('Plate setup')
-    expect(wrapper.findComponent(AppSidebar).props('badge')).toBe('ready')
-  })
-
-  it('exposes merged component props to the default slot', () => {
-    const wrapper = mountWorkspace(
-      {
-        doseDesignOptions: {
-          selectedWells: ['D1'],
-        },
-      },
-      {
-        default: (rawProps: unknown) => {
-          const props = rawProps as {
-            wellPlateProps: Record<string, unknown>
-            doseCalculatorProps: Record<string, unknown>
-          }
-          return h('pre', { class: 'slot-props' }, JSON.stringify({
-            plate: props.wellPlateProps.modelValue,
-            dose: props.doseCalculatorProps.targetWells,
-          }))
-        },
-      },
-    )
-
-    expect(JSON.parse(wrapper.find('.slot-props').text())).toEqual({
-      plate: ['D1'],
-      dose: ['D1'],
-    })
-  })
-})

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

@@ -1,108 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import ExperimentTimeline from '../../components/ExperimentTimeline.vue'
-import type { ProtocolStep } from '../../types'
-
-function makeSteps(): ProtocolStep[] {
-  return [
-    { id: 's1', name: 'Thaw', type: 'incubation', status: 'pending', order: 0 },
-    { id: 's2', name: 'Quench', type: 'incubation', status: 'pending', order: 1 },
-    { id: 's3', name: 'Extract', type: 'incubation', status: 'pending', order: 2 },
-  ]
-}
-
-describe('ExperimentTimeline', () => {
-  it('renders steps in order', () => {
-    const wrapper = mount(ExperimentTimeline, { props: { modelValue: makeSteps() } })
-
-    expect(wrapper.findAll('.mint-timeline__title').map(title => title.text()))
-      .toEqual(['Thaw', 'Quench', 'Extract'])
-  })
-
-  it('reorders a step with Alt and the arrow keys while editable', async () => {
-    const wrapper = mount(ExperimentTimeline, {
-      props: { modelValue: makeSteps(), editable: true },
-    })
-
-    const first = wrapper.findAll('.mint-timeline__step')[0]
-    expect(first.attributes('tabindex')).toBe('0')
-    expect(first.attributes('aria-label')).toContain('Press Alt with the arrow keys')
-
-    await first.trigger('keydown', { key: 'ArrowDown', altKey: true })
-
-    expect(wrapper.emitted('step-reorder')?.[0]).toEqual(['s1', 1])
-    const steps = wrapper.emitted('update:modelValue')?.[0]?.[0] as ProtocolStep[]
-    expect(steps.map(step => step.id)).toEqual(['s2', 's1', 's3'])
-    expect(steps.map(step => step.order)).toEqual([0, 1, 2])
-  })
-
-  it('announces the move politely', async () => {
-    const wrapper = mount(ExperimentTimeline, {
-      props: { modelValue: makeSteps(), editable: true },
-    })
-
-    await wrapper.findAll('.mint-timeline__step')[2]
-      .trigger('keydown', { key: 'ArrowUp', altKey: true })
-    await wrapper.vm.$nextTick()
-
-    const liveRegion = wrapper.get('[role="status"]')
-    expect(liveRegion.attributes('aria-live')).toBe('polite')
-    expect(liveRegion.text()).toBe('Extract moved to position 2 of 3.')
-  })
-
-  it('is not keyboard reorderable when not editable', async () => {
-    const wrapper = mount(ExperimentTimeline, { props: { modelValue: makeSteps() } })
-
-    const first = wrapper.findAll('.mint-timeline__step')[0]
-    expect(first.attributes('tabindex')).toBeUndefined()
-
-    await first.trigger('keydown', { key: 'ArrowDown', altKey: true })
-
-    expect(wrapper.emitted('step-reorder')).toBeUndefined()
-  })
-
-  describe('step progress (3d)', () => {
-    function mountWith(step: Partial<ProtocolStep>) {
-      const steps: ProtocolStep[] = [
-        { id: 'run', name: 'LC-MS', type: 'incubation', status: 'in_progress', order: 0, ...step },
-      ]
-      return mount(ExperimentTimeline, { props: { modelValue: steps } })
-    }
-
-    it('should render a progress bar when the in-progress step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('[role="progressbar"]').exists()).toBe(true)
-    })
-
-    it('should expose the value on the progress bar when the step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('[role="progressbar"]').attributes('aria-valuenow')).toBe('35')
-    })
-
-    it('should size the fill to the percent when the step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('.mint-timeline__progress-fill').attributes('style')).toContain('width: 35%')
-    })
-
-    it('should show the percent as text when the step has progress', () => {
-      expect(mountWith({ progress: 35 }).find('.mint-timeline__progress-value').text()).toBe('35%')
-    })
-
-    it('should round the percent text when progress is fractional', () => {
-      expect(mountWith({ progress: 34.6 }).find('.mint-timeline__progress-value').text()).toBe('35%')
-    })
-
-    it('should clamp the percent when progress exceeds 100', () => {
-      expect(mountWith({ progress: 140 }).find('.mint-timeline__progress-value').text()).toBe('100%')
-    })
-
-    it('should clamp the percent when progress is negative', () => {
-      expect(mountWith({ progress: -5 }).find('.mint-timeline__progress-value').text()).toBe('0%')
-    })
-
-    it('should render no progress bar when the in-progress step has no progress', () => {
-      expect(mountWith({}).find('[role="progressbar"]').exists()).toBe(false)
-    })
-
-    it('should render no progress bar when the step is not in progress', () => {
-      expect(mountWith({ status: 'completed', progress: 100 }).find('[role="progressbar"]').exists()).toBe(false)
-    })
-  })
-})

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

@@ -1,96 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import FitPanel from '../../components/FitPanel.vue'
-import type { FitResultSummary, FitSeries } from '../../types'
-
-const results: FitResultSummary[] = [
-  { label: 'IC50 (nM)', value: '42.7' },
-  { label: 'Hill slope', value: '-1.12', variant: 'success' },
-  { label: 'R²', value: '0.982', variant: 'success', verdict: true },
-]
-
-function mountCompleted() {
-  return mount(FitPanel, { props: { state: 'completed', results } })
-}
-
-describe('FitPanel', () => {
-  it('should list results as table rows when they carry no verdict, even with a variant', () => {
-    expect(mountCompleted().findAll('.mint-fit-panel__result-row').map(row => row.text()))
-      .toEqual(['IC50 (nM)42.7', 'Hill slope-1.12'])
-  })
-
-  it('should move a result into the check row when it is marked as a verdict', () => {
-    expect(mountCompleted().get('.mint-fit-panel__check--success').text()).toBe('R² 0.982')
-  })
-})
-
-const parameters: FitResultSummary[] = [
-  { label: 'IC50', unit: 'nM', value: '631', ci: '512 – 778' },
-  { label: 'Hill slope', value: '1.10', ci: '0.94 – 1.26' },
-]
-
-const series: FitSeries[] = [
-  { label: 'Control', results: parameters },
-  { label: 'Treatment A', color: 'var(--mint-sample-4)', results: [{ label: 'IC50', unit: 'nM', value: '39.8' }] },
-]
-
-describe('FitPanel parameter table (9b)', () => {
-  it('should render the unit in its own element when a result has a unit', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', results: parameters } })
-    expect(wrapper.get('.mint-fit-panel__result-unit').text()).toBe('nM')
-  })
-
-  it('should render a header row when results are shown', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', results: parameters } })
-    expect(wrapper.get('.mint-fit-panel__result-head').text()).toBe('ParameterValue95% CI')
-  })
-
-  it('should render the confidence interval when a result has one', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', results: parameters } })
-    expect(wrapper.get('.mint-fit-panel__result-ci').text()).toBe('512 – 778')
-  })
-
-  it('should omit the CI column when no result has a confidence interval', () => {
-    expect(mountCompleted().get('.mint-fit-panel__result-head').text()).toBe('ParameterValue')
-  })
-
-  it('should use custom column labels when columnLabels is set', () => {
-    const wrapper = mount(FitPanel, {
-      props: { state: 'completed', results: parameters, columnLabels: { parameter: '参数', value: '值' } },
-    })
-    expect(wrapper.get('.mint-fit-panel__result-head').text()).toBe('参数值95% CI')
-  })
-})
-
-describe('FitPanel series switch (9b)', () => {
-  it('should show the first series when series are given', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    expect(wrapper.findAll('.mint-fit-panel__result-row')).toHaveLength(2)
-  })
-
-  it('should show another series when its segment is selected', async () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    await wrapper.findAll('[role="radio"]')[1].trigger('click')
-    expect(wrapper.findAll('.mint-fit-panel__result-row')).toHaveLength(1)
-  })
-
-  it('should emit the selected series index when a segment is selected', async () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    await wrapper.findAll('[role="radio"]')[1].trigger('click')
-    expect(wrapper.emitted('update:activeSeries')?.[0]).toEqual([1])
-  })
-
-  it('should color a series segment with the group palette when the series has no color', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series } })
-    expect(wrapper.get('.mint-segmented-control__swatch').attributes('style')).toContain('var(--mint-sample-1)')
-  })
-
-  it('should render no series switch when series are not given', () => {
-    expect(mountCompleted().find('.mint-fit-panel__series').exists()).toBe(false)
-  })
-
-  it('should keep the series switch when the active series has no results', () => {
-    const wrapper = mount(FitPanel, { props: { state: 'completed', series: [{ label: 'Empty', results: [] }, ...series] } })
-    expect(wrapper.find('.mint-fit-panel__series').exists()).toBe(true)
-  })
-})

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

@@ -1,101 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import GroupAssigner from '../../components/GroupAssigner.vue'
-import type { GroupItem } from '../../types'
-
-const groups: GroupItem[] = [
-  { name: 'control-a', color: '#3B82F6', count: 3 },
-  { name: 'treatment-a', color: '#F43F5E', count: 4 },
-]
-
-describe('GroupAssigner', () => {
-  it('uses shared assignment state for counts, validation, and emitted updates', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: {
-        groups,
-        group1: ['control-a'],
-        group2: [],
-        minPerGroup: 1,
-      },
-    })
-
-    expect(wrapper.text()).toContain('3 samples')
-    expect(wrapper.text()).toContain('0 samples')
-    expect(wrapper.text()).toContain('Add 1 more to Treatment')
-
-    await wrapper.find('.mint-group-assigner__pill-remove').trigger('click')
-    expect(wrapper.emitted('update:group1')?.[0]).toEqual([[]])
-    expect(wrapper.emitted('update:group2')).toBeUndefined()
-  })
-
-  it('does not throw when drag events omit dataTransfer', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: {
-        groups,
-        group1: [],
-        group2: [],
-      },
-    })
-
-    await expect(
-      wrapper.find('.mint-group-assigner__pill--unassigned').trigger('dragstart', { dataTransfer: null }),
-    ).resolves.toBeUndefined()
-
-    await expect(
-      wrapper.find('.mint-group-assigner__zone').trigger('dragover', { dataTransfer: null }),
-    ).resolves.toBeUndefined()
-  })
-
-  it('assigns and unassigns groups with Alt and the arrow keys', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: [], group2: [] },
-    })
-
-    const pill = wrapper.get('.mint-group-assigner__pill--unassigned')
-    expect(pill.attributes('tabindex')).toBe('0')
-    expect(pill.attributes('aria-label')).toContain('Available Groups')
-
-    await pill.trigger('keydown', { key: 'ArrowLeft', altKey: true })
-    expect(wrapper.emitted('update:group1')?.[0]).toEqual([['control-a']])
-
-    await wrapper.get('.mint-group-assigner__pill--unassigned')
-      .trigger('keydown', { key: 'ArrowRight', altKey: true })
-    expect(wrapper.emitted('update:group2')?.at(-1)).toEqual([['control-a']])
-  })
-
-  it('moves an assigned group back to the unassigned pool', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: ['control-a'], group2: [] },
-    })
-
-    await wrapper.get('.mint-group-assigner__zone--1 .mint-group-assigner__pill')
-      .trigger('keydown', { key: 'ArrowRight', altKey: true })
-
-    expect(wrapper.emitted('update:group1')?.[0]).toEqual([[]])
-  })
-
-  it('announces keyboard assignments politely', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: [], group2: [] },
-    })
-
-    await wrapper.get('.mint-group-assigner__pill--unassigned')
-      .trigger('keydown', { key: 'ArrowLeft', altKey: true })
-    await wrapper.vm.$nextTick()
-
-    const liveRegion = wrapper.get('[role="status"]')
-    expect(liveRegion.attributes('aria-live')).toBe('polite')
-    expect(liveRegion.text()).toBe('control-a moved to Control.')
-  })
-
-  it('ignores arrow keys without Alt', async () => {
-    const wrapper = mount(GroupAssigner, {
-      props: { groups, group1: [], group2: [] },
-    })
-
-    await wrapper.get('.mint-group-assigner__pill--unassigned')
-      .trigger('keydown', { key: 'ArrowLeft' })
-
-    expect(wrapper.emitted('update:group1')).toBeUndefined()
-  })
-})

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

@@ -1,120 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { nextTick } from 'vue'
-import MobileSupportGate from '../../components/MobileSupportGate.vue'
-
-function mockMatchMedia(initialMatches: boolean) {
-  const listeners = new Set<(event: MediaQueryListEvent) => void>()
-  const queryList = {
-    matches: initialMatches,
-    media: '',
-    onchange: null,
-    addEventListener: vi.fn((_event: string, listener: (event: MediaQueryListEvent) => void) => {
-      listeners.add(listener)
-    }),
-    removeEventListener: vi.fn((_event: string, listener: (event: MediaQueryListEvent) => void) => {
-      listeners.delete(listener)
-    }),
-    addListener: vi.fn((listener: (event: MediaQueryListEvent) => void) => {
-      listeners.add(listener)
-    }),
-    removeListener: vi.fn((listener: (event: MediaQueryListEvent) => void) => {
-      listeners.delete(listener)
-    }),
-    dispatchEvent: vi.fn(),
-  } as unknown as MediaQueryList
-
-  Object.defineProperty(window, 'matchMedia', {
-    configurable: true,
-    value: vi.fn(() => queryList),
-  })
-
-  return {
-    setMatches(matches: boolean) {
-      Object.defineProperty(queryList, 'matches', {
-        configurable: true,
-        value: matches,
-      })
-      listeners.forEach(listener => listener({ matches } as MediaQueryListEvent))
-    },
-  }
-}
-
-describe('MobileSupportGate', () => {
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('shows the unsupported message on mobile when the route is unsupported', async () => {
-    mockMatchMedia(true)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: false,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(true)
-    expect(wrapper.text()).toContain('Desktop workspace recommended')
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(false)
-  })
-
-  it('renders content on desktop even when the route is mobile-unsupported', async () => {
-    mockMatchMedia(false)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: false,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(false)
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(true)
-  })
-
-  it('renders content on mobile when the route is supported', async () => {
-    mockMatchMedia(true)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: true,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(false)
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(true)
-  })
-
-  it('reacts when the viewport moves into the mobile query', async () => {
-    const media = mockMatchMedia(false)
-
-    const wrapper = mount(MobileSupportGate, {
-      props: {
-        supported: false,
-      },
-      slots: {
-        default: '<div data-testid="content">Workspace content</div>',
-      },
-    })
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="content"]').exists()).toBe(true)
-
-    media.setMatches(true)
-    await nextTick()
-
-    expect(wrapper.find('[data-testid="mobile-unsupported"]').exists()).toBe(true)
-  })
-})

package/src/__tests__/components/ReagentList.presentation.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { Reagent } from '../../types'
-import {
-  formatReagentExpiresIn,
-  formatReagentExpiryDate,
-  getReagentColumnValue,
-  getReagentRowClasses,
-  getReagentStockLevel,
-  isReagentExpired,
-  isReagentExpiringSoon,
-  isReagentLowStock,
-} from '../../components/ReagentList.presentation'
-
-describe('ReagentList presentation helpers', () => {
-  const reagent: Reagent = {
-    id: 'reagent-1',
-    name: 'Glucose',
-    catalogNumber: 'G-7528',
-    lotNumber: 'LOT-A',
-    supplier: 'Sigma',
-    expiryDate: '2026-06-01T00:00:00.000Z',
-    stockLevel: 12,
-  }
-
-  it('extracts sortable values for table columns', () => {
-    expect(getReagentColumnValue(reagent, 'name')).toBe('Glucose')
-    expect(getReagentColumnValue(reagent, 'catalog')).toBe('G-7528')
-    expect(getReagentColumnValue(reagent, 'expiry')).toBe(new Date(reagent.expiryDate!).getTime())
-    expect(getReagentColumnValue({ id: 'empty', name: 'Empty' }, 'stock')).toBeUndefined()
-  })
-
-  it('classifies expiry states relative to a supplied date', () => {
-    const now = new Date('2026-05-22T00:00:00.000Z')
-
-    expect(isReagentExpired(reagent, now)).toBe(false)
-    expect(isReagentExpiringSoon(reagent, 30, now)).toBe(true)
-    expect(isReagentExpired({ ...reagent, expiryDate: '2026-05-01T00:00:00.000Z' }, now)).toBe(true)
-  })
-
-  it('should count whole days left when a reagent expires soon', () => {
-    expect(formatReagentExpiresIn(reagent, new Date('2026-05-29T12:00:00.000Z'))).toBe('3 days left')
-  })
-
-  it('should use the singular when one day is left', () => {
-    expect(formatReagentExpiresIn(reagent, new Date('2026-05-31T12:00:00.000Z'))).toBe('1 day left')
-  })
-
-  it('classifies low stock', () => {
-    expect(isReagentLowStock(reagent, 15)).toBe(true)
-    expect(getReagentStockLevel({ id: 'missing', name: 'Missing' })).toBe(0)
-  })
-
-  it('formats missing and present expiry dates', () => {
-    expect(formatReagentExpiryDate(undefined)).toBe('-')
-    expect(formatReagentExpiryDate('2026-06-01T00:00:00.000Z')).toBe('Jun 2026')
-  })
-
-  it('builds row state classes without mixing expired and expiring-soon', () => {
-    expect(
-      getReagentRowClasses(reagent, {
-        lowStockThreshold: 15,
-        draggedId: 'reagent-1',
-        dragOverId: 'reagent-2',
-        now: new Date('2026-05-22T00:00:00.000Z'),
-      })
-    ).toEqual([
-      'mint-reagent-list__row',
-      'mint-reagent-list__row--expiring-soon',
-      'mint-reagent-list__row--low-stock',
-      'mint-reagent-list__row--dragging',
-    ])
-  })
-})