@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.4

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

@@ -0,0 +1,740 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { ref, nextTick } from 'vue'
+
+// ---------------------------------------------------------------------------
+// Mock useApi — intercepts all HTTP calls
+// ---------------------------------------------------------------------------
+
+const mockGet = vi.fn()
+const mockPost = vi.fn()
+const mockPatch = vi.fn()
+const mockUseApi = vi.fn((_options?: unknown) => ({
+  get: mockGet,
+  post: mockPost,
+  patch: mockPatch,
+}))
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: (options: unknown) => mockUseApi(options),
+}))
+
+import { useAnalysisArtifacts } from '../../composables/useAnalysisArtifacts'
+import type {
+  AnalysisArtifactDetail,
+  AnalysisArtifactSummary,
+} from '../../types/analysisArtifactTypes'
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeArtifact(
+  overrides: Partial<AnalysisArtifactSummary> = {},
+): AnalysisArtifactSummary {
+  return {
+    id: 1,
+    experiment_id: 42,
+    plugin_id: 'plugin-a',
+    artifact_key: 'default',
+    display_name: 'Dose Response Fit',
+    status: 'active',
+    result_keys: ['summary', 'tree'],
+    created_at: '2026-07-01T10:00:00Z',
+    updated_at: '2026-07-02T10:00:00Z',
+    ...overrides,
+  }
+}
+
+const ARTIFACTS = [
+  makeArtifact({ id: 1, plugin_id: 'plugin-a', artifact_key: 'fit', display_name: 'Dose Response Fit' }),
+  makeArtifact({ id: 2, plugin_id: 'plugin-b', artifact_key: 'peaks', display_name: 'Peak Table' }),
+  makeArtifact({
+    id: 3,
+    plugin_id: 'plugin-a',
+    artifact_key: 'old-fit',
+    display_name: 'Old Fit',
+    status: 'archived',
+    archived_at: '2026-07-03T10:00:00Z',
+  }),
+]
+
+function setup(options?: Parameters<typeof useAnalysisArtifacts>[0]) {
+  return useAnalysisArtifacts({ experimentId: 42, ...options })
+}
+
+/** Let watchers fire and their triggered requests settle. */
+async function flush(): Promise<void> {
+  await nextTick()
+  await Promise.resolve()
+  await Promise.resolve()
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('useAnalysisArtifacts', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({ artifacts: ARTIFACTS })
+    mockPost.mockResolvedValue(makeArtifact())
+    mockPatch.mockResolvedValue(makeArtifact())
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    window.history.replaceState({}, '', '/')
+  })
+
+  // -------------------------------------------------------------------------
+  // list
+  // -------------------------------------------------------------------------
+
+  describe('list', () => {
+    it('should call GET /experiments/{id}/analysis-artifacts with include_archived=false by default', async () => {
+      const { list } = setup()
+
+      await list()
+
+      expect(mockGet).toHaveBeenCalledOnce()
+      expect(mockGet).toHaveBeenCalledWith('/experiments/42/analysis-artifacts?include_archived=false')
+    })
+
+    it('should pass include_archived=true when includeArchived option is set', async () => {
+      const { list } = setup({ includeArchived: true })
+
+      await list()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/42/analysis-artifacts?include_archived=true')
+    })
+
+    it('should store and return the fetched artifacts', async () => {
+      const { list, artifacts } = setup()
+
+      const result = await list()
+
+      expect(result).toHaveLength(3)
+      expect(artifacts.value).toEqual(ARTIFACTS)
+    })
+
+    it('should filter to the given pluginId client-side', async () => {
+      const { list, artifacts } = setup({ pluginId: 'plugin-a' })
+
+      await list()
+
+      expect(artifacts.value.map((a) => a.id)).toEqual([1, 3])
+    })
+
+    it('should keep all plugins when pluginId is not provided', async () => {
+      const { list, artifacts } = setup()
+
+      await list()
+
+      expect(new Set(artifacts.value.map((a) => a.plugin_id))).toEqual(
+        new Set(['plugin-a', 'plugin-b']),
+      )
+    })
+
+    it('should set error and skip the request when no experiment id is available', async () => {
+      const { list, error } = useAnalysisArtifacts()
+
+      const result = await list()
+
+      expect(result).toEqual([])
+      expect(mockGet).not.toHaveBeenCalled()
+      expect(error.value).toContain('experiment')
+    })
+
+    it('should reset artifacts and set error on failure', async () => {
+      const { list, artifacts, error } = setup()
+      await list()
+      expect(artifacts.value).toHaveLength(3)
+
+      mockGet.mockRejectedValueOnce(new Error('Network error'))
+      const result = await list()
+
+      expect(result).toEqual([])
+      expect(artifacts.value).toEqual([])
+      expect(error.value).toBe('Network error')
+    })
+
+    it('should toggle isLoading during the call', async () => {
+      let resolveGet!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveGet = r }))
+
+      const { list, isLoading } = setup()
+      expect(isLoading.value).toBe(false)
+
+      const promise = list()
+      expect(isLoading.value).toBe(true)
+
+      resolveGet({ artifacts: [] })
+      await promise
+      expect(isLoading.value).toBe(false)
+    })
+
+    it('should update lastLoadedAt on success', async () => {
+      const { list, lastLoadedAt } = setup()
+      expect(lastLoadedAt.value).toBeNull()
+
+      await list()
+
+      expect(lastLoadedAt.value).toBeInstanceOf(Date)
+    })
+  })
+
+  describe('resolveTarget', () => {
+    it('should resolve the exact stable identity when the numeric hint is stale', async () => {
+      const detail = {
+        ...makeArtifact({
+          id: 2,
+          experiment_id: 42,
+          plugin_id: 'plugin-b',
+          artifact_key: 'peaks',
+        }),
+        result: { schema_version: 'mint.analysis_file.v1' },
+        tree: [],
+        summary: null,
+      } satisfies AnalysisArtifactDetail
+      mockGet
+        .mockResolvedValueOnce({ artifacts: ARTIFACTS })
+        .mockResolvedValueOnce(detail)
+      const { resolveTarget } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 42,
+        artifactPluginId: 'plugin-b',
+        artifactKey: 'peaks',
+        artifactId: 999,
+      })
+
+      expect({
+        resolvedId: resolved?.id,
+        detailPath: mockGet.mock.calls[1]?.[0],
+      }).toEqual({
+        resolvedId: 2,
+        detailPath: '/experiments/42/analysis-artifacts/2',
+      })
+    })
+
+    it('should fail explicitly when the stable identity is not available', async () => {
+      const { resolveTarget, error } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 42,
+        artifactPluginId: 'LEAF',
+        artifactKey: 'missing',
+      })
+
+      expect({ resolved, error: error.value }).toEqual({
+        resolved: null,
+        error: 'Analysis artifact LEAF/missing is not available.',
+      })
+    })
+
+    it('should reject a target from another experiment before making a request', async () => {
+      const { resolveTarget, error } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 66,
+        artifactPluginId: 'LEAF',
+        artifactKey: 'result',
+      })
+
+      expect({
+        resolved,
+        error: error.value,
+        requests: mockGet.mock.calls,
+      }).toEqual({
+        resolved: null,
+        error: 'Analysis artifact target belongs to experiment 66, not 42.',
+        requests: [],
+      })
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // experiment id resolution
+  // -------------------------------------------------------------------------
+
+  describe('experiment id resolution', () => {
+    it('should accept a ref experiment id', async () => {
+      const experimentId = ref<number | undefined>(7)
+      const { list } = useAnalysisArtifacts({ experimentId })
+
+      await list()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/7/analysis-artifacts?include_archived=false')
+    })
+
+    it('should accept a getter experiment id', async () => {
+      const { list } = useAnalysisArtifacts({ experimentId: () => 9 })
+
+      await list()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/9/analysis-artifacts?include_archived=false')
+    })
+
+    it('should fall back to the injected platform context', async () => {
+      ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
+        currentExperimentId: 33,
+      }
+      const { list } = useAnalysisArtifacts()
+
+      await list()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/33/analysis-artifacts?include_archived=false')
+    })
+
+    it('should fall back to the URL experiment id', async () => {
+      window.history.replaceState({}, '', '/?experimentId=55')
+      const { list } = useAnalysisArtifacts()
+
+      await list()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/55/analysis-artifacts?include_archived=false')
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // visibleArtifacts filtering
+  // -------------------------------------------------------------------------
+
+  describe('visibleArtifacts', () => {
+    it('should show only active artifacts by default', async () => {
+      const { list, visibleArtifacts } = setup({ includeArchived: true })
+
+      await list()
+
+      expect(visibleArtifacts.value.map((a) => a.id)).toEqual([1, 2])
+    })
+
+    it('should show archived artifacts when statusFilter is "archived"', async () => {
+      const { list, visibleArtifacts, statusFilter } = setup({ includeArchived: true })
+      await list()
+
+      statusFilter.value = 'archived'
+
+      expect(visibleArtifacts.value.map((a) => a.id)).toEqual([3])
+    })
+
+    it('should show everything when statusFilter is "all"', async () => {
+      const { list, visibleArtifacts, statusFilter } = setup({ includeArchived: true })
+      await list()
+
+      statusFilter.value = 'all'
+
+      expect(visibleArtifacts.value).toHaveLength(3)
+    })
+
+    it('should refetch with include_archived=true when statusFilter widens past "active"', async () => {
+      const { list, statusFilter } = setup()
+      await list()
+      expect(mockGet).toHaveBeenLastCalledWith('/experiments/42/analysis-artifacts?include_archived=false')
+
+      statusFilter.value = 'all'
+      await nextTick()
+      await Promise.resolve()
+
+      expect(mockGet).toHaveBeenLastCalledWith('/experiments/42/analysis-artifacts?include_archived=true')
+    })
+
+    it('should filter by search over display_name and artifact_key (case-insensitive)', async () => {
+      const { list, visibleArtifacts, search } = setup()
+      await list()
+
+      search.value = 'PEAK'
+      expect(visibleArtifacts.value.map((a) => a.id)).toEqual([2])
+
+      search.value = 'fit'
+      expect(visibleArtifacts.value.map((a) => a.id)).toEqual([1])
+    })
+
+    it('should filter by pluginFilter', async () => {
+      const { list, visibleArtifacts, pluginFilter } = setup()
+      await list()
+
+      pluginFilter.value = 'plugin-b'
+
+      expect(visibleArtifacts.value.map((a) => a.id)).toEqual([2])
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // getDetail
+  // -------------------------------------------------------------------------
+
+  describe('getDetail', () => {
+    it('should GET the artifact detail and store it in selectedDetail', async () => {
+      const detail = { ...makeArtifact(), result: { x: 1 }, tree: [], summary: null }
+      mockGet.mockResolvedValueOnce(detail)
+      const { getDetail, selectedDetail } = setup()
+
+      const result = await getDetail(1)
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/42/analysis-artifacts/1')
+      expect(result).toEqual(detail)
+      expect(selectedDetail.value).toEqual(detail)
+    })
+
+    it('should return null and set error on failure', async () => {
+      mockGet.mockRejectedValueOnce(new Error('Not found'))
+      const { getDetail, selectedDetail, error } = setup()
+
+      const result = await getDetail(99)
+
+      expect(result).toBeNull()
+      expect(selectedDetail.value).toBeNull()
+      expect(error.value).toBe('Not found')
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // mutations
+  // -------------------------------------------------------------------------
+
+  describe('updateMetadata', () => {
+    it('should PATCH the metadata and splice the returned summary into artifacts', async () => {
+      const { list, updateMetadata, artifacts } = setup()
+      await list()
+
+      const renamed = makeArtifact({ id: 1, artifact_key: 'fit', display_name: 'Renamed' })
+      mockPatch.mockResolvedValueOnce(renamed)
+
+      const updated = await updateMetadata(1, { display_name: 'Renamed' })
+
+      expect(updated).toMatchObject({ id: 1, display_name: 'Renamed' })
+      expect(mockPatch).toHaveBeenCalledWith('/experiments/42/analysis-artifacts/1', {
+        display_name: 'Renamed',
+      })
+      expect(artifacts.value.find((a) => a.id === 1)?.display_name).toBe('Renamed')
+    })
+
+    it('should return null and set error on failure', async () => {
+      mockPatch.mockRejectedValueOnce(new Error('Forbidden'))
+      const { updateMetadata, error } = setup()
+
+      const updated = await updateMetadata(1, { note: 'x' })
+
+      expect(updated).toBeNull()
+      expect(error.value).toBe('Forbidden')
+    })
+  })
+
+  describe('archive / restore', () => {
+    it('should POST archive and splice the returned summary', async () => {
+      const { list, archive, artifacts } = setup()
+      await list()
+
+      const archived = makeArtifact({ id: 1, artifact_key: 'fit', status: 'archived' })
+      mockPost.mockResolvedValueOnce(archived)
+
+      const result = await archive(1)
+
+      // Returns the post-mutation summary so callers never report a stale status.
+      expect(result).toMatchObject({ id: 1, status: 'archived' })
+      expect(mockPost).toHaveBeenCalledWith('/experiments/42/analysis-artifacts/1/archive')
+      expect(artifacts.value.find((a) => a.id === 1)?.status).toBe('archived')
+    })
+
+    it('should POST restore and splice the returned summary', async () => {
+      const { list, restore, artifacts } = setup({ includeArchived: true })
+      await list()
+
+      const restored = makeArtifact({ id: 3, artifact_key: 'old-fit', status: 'active' })
+      mockPost.mockResolvedValueOnce(restored)
+
+      const result = await restore(3)
+
+      expect(result).toMatchObject({ id: 3, status: 'active' })
+      expect(mockPost).toHaveBeenCalledWith('/experiments/42/analysis-artifacts/3/restore')
+      expect(artifacts.value.find((a) => a.id === 3)?.status).toBe('active')
+    })
+
+    it('should keep isMutating true until every mutation settles', async () => {
+      let resolveFirst!: (v: unknown) => void
+      mockPost.mockImplementationOnce(() => new Promise((r) => { resolveFirst = r }))
+      let resolveSecond!: (v: unknown) => void
+      mockPost.mockImplementationOnce(() => new Promise((r) => { resolveSecond = r }))
+
+      const { archive, isMutating } = setup()
+      const first = archive(1)
+      const second = archive(2)
+
+      resolveSecond(makeArtifact({ id: 2, status: 'archived' }))
+      await second
+      expect(isMutating.value).toBe(true)
+
+      resolveFirst(makeArtifact({ id: 1, status: 'archived' }))
+      await first
+      expect(isMutating.value).toBe(false)
+    })
+
+    it('should toggle isMutating during archive', async () => {
+      let resolvePost!: (v: unknown) => void
+      mockPost.mockImplementationOnce(() => new Promise((r) => { resolvePost = r }))
+
+      const { archive, isMutating } = setup()
+      expect(isMutating.value).toBe(false)
+
+      const promise = archive(1)
+      expect(isMutating.value).toBe(true)
+
+      resolvePost(makeArtifact())
+      await promise
+      expect(isMutating.value).toBe(false)
+    })
+
+    it('should return null on archive failure', async () => {
+      mockPost.mockRejectedValueOnce(new Error('Conflict'))
+      const { archive, error } = setup()
+
+      const result = await archive(1)
+
+      expect(result).toBeNull()
+      expect(error.value).toBe('Conflict')
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // helpers
+  // -------------------------------------------------------------------------
+
+  describe('hasArtifactKey', () => {
+    it('should report whether a key exists in the loaded artifacts', async () => {
+      const { list, hasArtifactKey } = setup()
+      await list()
+
+      expect(hasArtifactKey('fit')).toBe(true)
+      expect(hasArtifactKey('nope')).toBe(false)
+    })
+  })
+
+  describe('clear', () => {
+    it('should reset artifacts, selectedDetail, and error', async () => {
+      mockGet.mockRejectedValueOnce(new Error('boom'))
+      const { list, clear, artifacts, selectedDetail, error } = setup()
+      await list()
+      expect(error.value).toBe('boom')
+
+      clear()
+
+      expect(artifacts.value).toEqual([])
+      expect(selectedDetail.value).toBeNull()
+      expect(error.value).toBeNull()
+    })
+  })
+
+  describe('immediate', () => {
+    it('should fetch on creation when immediate is set and an experiment id exists', async () => {
+      setup({ immediate: true })
+
+      await Promise.resolve()
+      await Promise.resolve()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/42/analysis-artifacts?include_archived=false')
+    })
+
+    it('should not fetch on creation without immediate', async () => {
+      setup()
+
+      await Promise.resolve()
+
+      expect(mockGet).not.toHaveBeenCalled()
+    })
+
+    it('should fetch once a late-resolving experiment id becomes available', async () => {
+      const experimentId = ref<number | undefined>(undefined)
+      useAnalysisArtifacts({ experimentId, immediate: true })
+
+      await flush()
+      expect(mockGet).not.toHaveBeenCalled()
+
+      experimentId.value = 77
+      await flush()
+
+      expect(mockGet).toHaveBeenCalledWith('/experiments/77/analysis-artifacts?include_archived=false')
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // Reactivity
+  // -------------------------------------------------------------------------
+
+  describe('reactive options', () => {
+    it('should refetch when the experiment id changes after a load', async () => {
+      const experimentId = ref<number | undefined>(42)
+      const { list } = useAnalysisArtifacts({ experimentId })
+      await list()
+
+      experimentId.value = 43
+      await flush()
+
+      expect(mockGet).toHaveBeenLastCalledWith('/experiments/43/analysis-artifacts?include_archived=false')
+    })
+
+    it('should re-scope artifacts when a reactive pluginId changes without refetching', async () => {
+      const pluginId = ref<string | null>('plugin-a')
+      const { list, artifacts } = useAnalysisArtifacts({ experimentId: 42, pluginId })
+      await list()
+      expect(artifacts.value.map((a) => a.id)).toEqual([1, 3])
+
+      pluginId.value = 'plugin-b'
+      await flush()
+
+      expect(artifacts.value.map((a) => a.id)).toEqual([2])
+      expect(mockGet).toHaveBeenCalledOnce()
+    })
+
+    it('should refetch with include_archived=true when a reactive includeArchived flips on', async () => {
+      const includeArchived = ref(false)
+      const { list } = useAnalysisArtifacts({ experimentId: 42, includeArchived })
+      await list()
+
+      includeArchived.value = true
+      await flush()
+
+      expect(mockGet).toHaveBeenLastCalledWith('/experiments/42/analysis-artifacts?include_archived=true')
+    })
+
+    it('should not fetch when statusFilter widens before anything requested a list', async () => {
+      const { statusFilter } = setup()
+
+      statusFilter.value = 'archived'
+      await flush()
+
+      expect(mockGet).not.toHaveBeenCalled()
+    })
+
+    it('should refetch when statusFilter widens while the first list is still in flight', async () => {
+      let resolveGet!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveGet = r }))
+
+      const { list, statusFilter } = setup()
+      const pending = list()
+
+      statusFilter.value = 'archived'
+      await flush()
+
+      expect(mockGet).toHaveBeenLastCalledWith('/experiments/42/analysis-artifacts?include_archived=true')
+
+      resolveGet({ artifacts: [] })
+      await pending
+    })
+
+    it('should refetch when statusFilter widens after a failed load', async () => {
+      mockGet.mockRejectedValueOnce(new Error('Network error'))
+      const { list, statusFilter } = setup()
+      await list()
+
+      statusFilter.value = 'archived'
+      await flush()
+
+      expect(mockGet).toHaveBeenLastCalledWith('/experiments/42/analysis-artifacts?include_archived=true')
+    })
+
+    it('should clear artifacts and selection when the experiment id goes away', async () => {
+      const experimentId = ref<number | undefined>(42)
+      const { list, getDetail, artifacts, selectedDetail } = useAnalysisArtifacts({ experimentId })
+      await list()
+      mockGet.mockResolvedValueOnce({ ...makeArtifact(), result: {}, tree: [], summary: null })
+      await getDetail(1)
+      expect(artifacts.value).toHaveLength(3)
+      expect(selectedDetail.value).not.toBeNull()
+
+      experimentId.value = undefined
+      await flush()
+
+      expect(artifacts.value).toEqual([])
+      expect(selectedDetail.value).toBeNull()
+    })
+
+    it('should not let a request from a dropped experiment repopulate state', async () => {
+      const experimentId = ref<number | undefined>(42)
+      let resolveGet!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveGet = r }))
+
+      const { list, artifacts } = useAnalysisArtifacts({ experimentId })
+      const pending = list()
+
+      experimentId.value = undefined
+      await flush()
+
+      resolveGet({ artifacts: ARTIFACTS })
+      await pending
+
+      expect(artifacts.value).toEqual([])
+    })
+
+    it('should ignore a stale failure that lands after a newer success', async () => {
+      let rejectStale!: (e: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((_r, reject) => { rejectStale = reject }))
+
+      const { list, artifacts, error } = setup()
+      const stalePromise = list()
+
+      mockGet.mockResolvedValueOnce({ artifacts: ARTIFACTS })
+      await list()
+      expect(artifacts.value).toHaveLength(3)
+
+      rejectStale(new Error('Stale network error'))
+      await stalePromise
+
+      expect(error.value).toBeNull()
+      expect(artifacts.value).toHaveLength(3)
+    })
+
+    it('should ignore a stale detail response that resolves after a newer one', async () => {
+      let resolveStale!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveStale = r }))
+
+      const { getDetail, selectedDetail } = setup()
+      const stalePromise = getDetail(1)
+
+      const fresh = { ...makeArtifact({ id: 2 }), result: { fresh: true }, tree: [], summary: null }
+      mockGet.mockResolvedValueOnce(fresh)
+      await getDetail(2)
+      expect(selectedDetail.value?.id).toBe(2)
+
+      resolveStale({ ...makeArtifact({ id: 1 }), result: { stale: true }, tree: [], summary: null })
+      const staleResult = await stalePromise
+
+      expect(staleResult).toBeNull()
+      expect(selectedDetail.value?.id).toBe(2)
+    })
+
+    it('should keep isLoading true while any request is still in flight', async () => {
+      let resolveFirst!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveFirst = r }))
+      let resolveSecond!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveSecond = r }))
+
+      const { list, isLoading } = setup()
+      const first = list()
+      const second = list()
+      expect(isLoading.value).toBe(true)
+
+      resolveSecond({ artifacts: [] })
+      await second
+      resolveFirst({ artifacts: [] })
+      await first
+
+      expect(isLoading.value).toBe(false)
+    })
+
+    it('should ignore a stale in-flight response that resolves after a newer one', async () => {
+      const stale = [makeArtifact({ id: 99, display_name: 'Stale' })]
+      let resolveStale!: (v: unknown) => void
+      mockGet.mockImplementationOnce(() => new Promise((r) => { resolveStale = r }))
+
+      const { list, artifacts } = setup()
+      const stalePromise = list()
+
+      mockGet.mockResolvedValueOnce({ artifacts: ARTIFACTS })
+      await list()
+      expect(artifacts.value).toHaveLength(3)
+
+      resolveStale({ artifacts: stale })
+      await stalePromise
+
+      expect(artifacts.value.map((a) => a.id)).toEqual([1, 2, 3])
+    })
+  })
+})