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

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

@@ -1,740 +0,0 @@
-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])
-    })
-  })
-})