Files
faunosteo/apps/app/tests/unit/routes.catalogue.test.tsx
T
bchanot b378cf066f fix(app): card retry keeps focus and voice when no retry is left
A retry ending on a failure with no retry (network to integrity, engine
stopped for good) keeps the polite region and moves focus to Consulter.
Busy look on Réessayer, error tone once the engine stopped, one attempt
for two calls in one tick; tests for the stopped engine, two core cards
and no blob URL after unmount.
2026-11-17 00:59:30 +01:00

683 lines
33 KiB
TypeScript

import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { MemoryRouter, Route, Routes } from 'react-router-dom'
import type { PreviewState } from '@faunosteo/core-wasm/types'
import { createFakeSupabase, fakeProfile, fakeUser, type FakeSupabase } from '../helpers/fakeSupabase'
import { bundledSheet } from '../helpers/sheet'
import { controlStopped } from '../helpers/core'
const mocks = vi.hoisted(() => ({ fake: null as unknown }))
vi.mock('@/lib/supabase', () => ({
getSupabaseClient: () => (mocks.fake as FakeSupabase | null)?.client ?? null,
isSupabaseConfigured: () => mocks.fake !== null,
}))
import CatalogRoute from '@/app/routes/app/anatomy/CatalogRoute'
import SheetRoute from '@/app/routes/app/anatomy/SheetRoute'
import { coreRuntime } from '@/core/runtime'
import { CataloguePreview } from '@/catalogue/preview'
import { cardFailure, coreFailure, serverFailure, type CatalogueFailure } from '@/catalogue/failure'
import { SheetFailure } from '@faunosteo/supabase'
import { useAuthStore } from '@/state/authStore'
import { useLocaleStore } from '@/state/localeStore'
import { fr } from '@/i18n/fr'
import { en } from '@/i18n/en'
/**
* The catalogue screens (V1-2.5 slice I, boards 01 to 03) on a fake client and
* the real core: the equine draft stands for a published version, its
* drawing served as Storage would, so the core checks the hash, the
* fingerprint and the caps exactly as in the browser.
*/
const SHEET = '503dc301-0000-4000-8000-000000000001'
const OTHER = '503dc301-0000-4000-8000-000000000002'
const V1 = 'aaaaaaaa-0000-4000-8000-000000000001'
const V2 = 'aaaaaaaa-0000-4000-8000-000000000002'
const V3 = 'aaaaaaaa-0000-4000-8000-000000000003'
const DOG = 'bbbbbbbb-0000-4000-8000-000000000001'
let fake: FakeSupabase
let document: unknown
let assetId: string
let sha256: string
let bytes: Uint8Array<ArrayBuffer>
let fingerprint: string
beforeAll(async () => {
const bundle = await bundledSheet()
document = bundle.document
;[assetId] = Object.keys(bundle.assets)
sha256 = bundle.assetHashes[assetId]
bytes = new TextEncoder().encode(bundle.assets[assetId])
// The fingerprint a publication stores: the core's, read from a draft preview.
const draft = new CataloguePreview(
coreRuntime(),
{ status: 'draft', document: JSON.stringify(document) },
[{ assetId, sha256, bytes }],
)
const state = draft.state()
if (!state.ok || !state.value.fingerprint) throw new Error('draft preview refused')
fingerprint = state.value.fingerprint
draft.free()
})
function versionAnswer(id: string, status: 'published' | 'deprecated', patch: Record<string, unknown> = {}) {
return {
sheet_id: SHEET,
version_id: id,
version_number: Number(id.slice(-1)),
status,
species_id: 'equine',
document,
revision: 1,
// PreviewSheet requires the stored fingerprint for deprecated versions too, while
// `get_sheet_version` returns it for published ones only (gap reported at V1-2.5).
fingerprint,
drawings: [{ asset_id: assetId, sha256, byte_size: bytes.length }],
...patch,
}
}
/** `get_sheet_version` answers per id, as the server would; unknown ids are `not_found`. */
function serveVersions(answers: Record<string, unknown>) {
fake.rpcResults.get_sheet_version = () => {
const [, args] = fake.rpcCalls.filter(([n]) => n === 'get_sheet_version').at(-1)!
const answer = answers[(args as { version_id: string }).version_id]
return answer ? { data: answer } : { error: { message: 'not_found', code: '42501' } }
}
}
function mount(path: string) {
return render(
<MemoryRouter initialEntries={[path]}>
<Routes>
<Route path="/app/anatomy" element={<CatalogRoute />} />
<Route path="/app/anatomy/:sheetId" element={<SheetRoute />} />
<Route path="/app/anatomy/:sheetId/versions/:number" element={<SheetRoute />} />
</Routes>
</MemoryRouter>,
)
}
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
useAuthStore.setState({ status: 'signed_in', user: fakeUser(), profile: fakeProfile(), catalogGrants: [] })
fake = createFakeSupabase()
fake.tables.species = [
{ id: 'equine', name_fr: 'Cheval', name_en: 'Horse', sort_order: 1 },
{ id: 'canine', name_fr: 'Chien', name_en: 'Dog', sort_order: 2 },
]
fake.tables.anatomical_sheet_versions = [
{ sheet_id: SHEET, id: V3, version_number: 3, status: 'published', published_at: '2026-10-28T10:00:00Z', deprecated_at: null },
{ sheet_id: SHEET, id: V2, version_number: 2, status: 'deprecated', published_at: '2026-10-20T10:00:00Z', deprecated_at: '2026-10-28T10:00:00Z' },
{ sheet_id: SHEET, id: V1, version_number: 1, status: 'published', published_at: '2026-10-10T10:00:00Z', deprecated_at: null },
]
fake.rpcResults.list_official_catalog = {
data: [
{ sheet_id: SHEET, species_id: 'equine', slug: 'cheval', name: { fr: 'Cheval', en: 'Horse' }, description: {}, version_number: 3, version_id: V3 },
{ sheet_id: OTHER, species_id: 'canine', slug: 'chien', name: { fr: 'Chien, rachis', en: 'Dog spine' }, description: {}, version_number: 1, version_id: DOG },
],
}
serveVersions({ [V3]: versionAnswer(V3, 'published'), [V2]: versionAnswer(V2, 'deprecated'), [V1]: versionAnswer(V1, 'published') })
fake.storage.download.mockImplementation(async () => ({ data: new Blob([bytes]), error: null }))
mocks.fake = fake
})
afterEach(() => cleanup())
describe('/app/anatomy', () => {
it('shows each published sheet with its species, status, version line and link', async () => {
mount('/app/anatomy')
expect(await screen.findByRole('heading', { level: 1, name: fr['shell.nav.anatomy'] })).toBeInTheDocument()
const card = (await screen.findByRole('heading', { level: 2, name: 'Cheval' })).closest('article')!
expect(within(card).getByText(fr['catalogue.status.published'])).toBeInTheDocument()
expect(within(card).getByText('Cheval', { selector: 'span' })).toBeInTheDocument()
expect(
await within(card).findByText('Version 3 · publiée le 28/10/2026 · 2 vues, 27 zones de constats'),
).toBeInTheDocument()
// The thumbnail is the core's composed main view, as an image (never inserted as markup).
expect(card.querySelector('img')?.getAttribute('src')).toMatch(/^blob:/)
expect(within(card).getByRole('link', { name: 'Consulter Cheval' })).toHaveAttribute('href', `/app/anatomy/${SHEET}`)
// The card whose version cannot be read keeps its name, version and link.
const dog = screen.getByRole('heading', { level: 2, name: 'Chien, rachis' }).closest('article')!
expect(within(dog).getByText('Version 1')).toBeInTheDocument()
// Its refused read is said in the card (F7).
expect(await within(dog).findByText(fr['access_denied.title'])).toBeInTheDocument()
})
it('searches by sheet name in either language and filters by species', async () => {
mount('/app/anatomy')
await screen.findByRole('heading', { level: 2, name: 'Cheval' })
const search = screen.getByRole('searchbox', { name: fr['catalogue.search'] })
await userEvent.type(search, 'dog')
expect(screen.queryByRole('heading', { level: 2, name: 'Cheval' })).toBeNull()
expect(screen.getByRole('heading', { level: 2, name: 'Chien, rachis' })).toBeInTheDocument()
await userEvent.clear(search)
await userEvent.type(search, 'thoracique')
expect(screen.getByText(fr['catalogue.no_results'])).toBeInTheDocument()
await userEvent.clear(search)
const chips = screen.getByRole('group', { name: fr['catalogue.species_filter'] })
expect(within(chips).getAllByRole('button').map((b) => b.textContent)).toEqual([
fr['catalogue.all_species'],
'Cheval',
'Chien',
])
await userEvent.click(within(chips).getByRole('button', { name: 'Cheval' }))
expect(screen.getByRole('heading', { level: 2, name: 'Cheval' })).toBeInTheDocument()
expect(screen.queryByRole('heading', { level: 2, name: 'Chien, rachis' })).toBeNull()
})
it('says when no sheet is published', async () => {
fake.rpcResults.list_official_catalog = { data: [] }
mount('/app/anatomy')
expect(await screen.findByText(fr['catalogue.empty'])).toBeInTheDocument()
})
it('shows « Accès non autorisé » on the server refusal', async () => {
fake.rpcResults.list_official_catalog = { error: { message: 'rights.catalog', code: '42501' } }
mount('/app/anatomy')
expect(await screen.findByRole('heading', { name: fr['access_denied.title'] })).toBeInTheDocument()
})
it('names an unavailable server and reads again on retry', async () => {
fake.rpcResults.list_official_catalog = { error: { message: 'boom' } }
mount('/app/anatomy')
expect(await screen.findByText(fr['catalogue.failure.unavailable'])).toBeInTheDocument()
fake.rpcResults.list_official_catalog = { data: [] }
await userEvent.click(screen.getByRole('button', { name: fr['common.retry'] }))
expect(await screen.findByText(fr['catalogue.empty'])).toBeInTheDocument()
})
})
describe('/app/anatomy/:sheetId', () => {
it('shows the current version: views, zone panel, references and disclaimer', async () => {
mount(`/app/anatomy/${SHEET}`)
expect(await screen.findByRole('heading', { level: 1, name: 'Cheval' })).toBeInTheDocument()
expect(screen.getByText('Version 3 · publiée le 28/10/2026')).toBeInTheDocument()
const tabs = screen.getAllByRole('tab')
expect(tabs.map((tab) => tab.textContent)).toEqual(['Vue latérale gauche', 'Tête (vue latérale gauche)'])
expect(tabs[0]).toHaveAttribute('aria-selected', 'true')
const canvas = screen.getByTestId('catalogue-canvas-drawing')
await waitFor(() => expect(canvas.querySelector('svg')).not.toBeNull())
fireEvent.click(canvas.querySelector('[data-anno-id="thoracic"]')!)
expect(screen.getByRole('heading', { name: 'Zone : Vertèbres thoraciques' })).toBeInTheDocument()
expect(screen.getByText('Catégorie : Segments vertébraux · vertèbres T1 à T18')).toBeInTheDocument()
expect(screen.getByRole('heading', { level: 3, name: 'Dysfonctions ostéopathiques' })).toBeInTheDocument()
expect(canvas.querySelector('[data-anno-id="thoracic"]')).toHaveAttribute('data-state', 'current')
expect(screen.getByRole('heading', { name: fr['catalogue.references.title'] })).toBeInTheDocument()
expect(screen.getByText(/Code rural et de la pêche maritime, art\. L\. 243-3/)).toBeInTheDocument()
expect(screen.getByText(/Aucun diagnostic médical n'est posé/)).toBeInTheDocument()
// No capability: no link to the administration.
expect(screen.queryByRole('link', { name: fr['catalogue.open_admin'] })).toBeNull()
})
it('keeps the zone panel when the empty drawing is tapped (reader: no deselect)', async () => {
mount(`/app/anatomy/${SHEET}`)
const canvas = await screen.findByTestId('catalogue-canvas-drawing')
await waitFor(() => expect(canvas.querySelector('[data-anno-id="thoracic"]')).not.toBeNull())
fireEvent.click(canvas.querySelector('[data-anno-id="thoracic"]')!)
const empty = canvas.querySelector('svg')!
const init = { pointerId: 1, isPrimary: true, button: 0, pointerType: 'mouse' }
fireEvent.pointerDown(empty, init)
fireEvent.pointerUp(empty, init)
fireEvent.click(empty)
expect(screen.getByRole('heading', { name: 'Zone : Vertèbres thoraciques' })).toBeInTheDocument()
expect(canvas.querySelector('[data-anno-id="thoracic"]')).toHaveAttribute('data-state', 'current')
})
it('opens the detail view from its link on the drawing', async () => {
mount(`/app/anatomy/${SHEET}`)
const canvas = await screen.findByTestId('catalogue-canvas-drawing')
await waitFor(() => expect(canvas.querySelector('[data-anno-id="head-trigger"]')).not.toBeNull())
fireEvent.click(canvas.querySelector('[data-anno-id="head-trigger"]')!)
expect(screen.getByRole('tab', { name: 'Tête (vue latérale gauche)' })).toHaveAttribute('aria-selected', 'true')
})
it('lists the versions with the « Retirée » mark, each linking to its page', async () => {
mount(`/app/anatomy/${SHEET}`)
await userEvent.click(await screen.findByRole('button', { name: '2 versions antérieures' }))
const list = screen.getByRole('list', { name: fr['catalogue.versions.title'] })
const links = within(list).getAllByRole('link')
expect(links.map((l) => l.getAttribute('href'))).toEqual([3, 2, 1].map((n) => `/app/anatomy/${SHEET}/versions/${n}`))
expect(links[0]).toHaveAttribute('aria-current', 'page')
expect(within(links[1]).getByText(fr['catalogue.status.deprecated'])).toBeInTheDocument()
})
it('opens a retired version by number with its mark', async () => {
mount(`/app/anatomy/${SHEET}/versions/2`)
expect(await screen.findByText('Version 2 · publiée le 20/10/2026')).toBeInTheDocument()
expect(screen.getByText(fr['catalogue.status.deprecated'])).toBeInTheDocument()
expect(fake.rpcCalls.filter(([n]) => n === 'get_sheet_version').map(([, a]) => a)).toEqual([{ version_id: V2 }])
})
it('links an editor to the administration', async () => {
useAuthStore.setState({ catalogGrants: [{ kind: 'sheet_editor', expires_at: null, revoked_at: null }] })
mount(`/app/anatomy/${SHEET}`)
expect(await screen.findByRole('link', { name: fr['catalogue.open_admin'] })).toHaveAttribute(
'href',
`/app/admin/sheets/${SHEET}`,
)
})
it.each([
['an unknown sheet', `/app/anatomy/${OTHER}`],
['a malformed id', '/app/anatomy/not-a-uuid'],
['an unknown number', `/app/anatomy/${SHEET}/versions/9`],
['a malformed number', `/app/anatomy/${SHEET}/versions/0`],
])('shows « Accès non autorisé » for %s', async (_case, path) => {
mount(path)
expect(await screen.findByRole('heading', { name: fr['access_denied.title'] })).toBeInTheDocument()
})
it('shows « Accès non autorisé » when the version read is refused', async () => {
serveVersions({})
mount(`/app/anatomy/${SHEET}`)
expect(await screen.findByRole('heading', { name: fr['access_denied.title'] })).toBeInTheDocument()
})
it('zooms with the buttons and « Ajuster » brings the whole drawing back', async () => {
mount(`/app/anatomy/${SHEET}`)
const drawing = await screen.findByTestId('catalogue-canvas-drawing')
expect(drawing.style.transform).toBe('translate(0px, 0px) scale(1)')
await userEvent.click(screen.getByRole('button', { name: fr['catalogue.zoom.in'] }))
expect(drawing.style.transform).toContain('scale(1.5)')
await userEvent.click(screen.getByRole('button', { name: fr['catalogue.zoom.in'] }))
expect(drawing.style.transform).toContain('scale(2.25)')
await userEvent.click(screen.getByRole('button', { name: fr['catalogue.zoom.out'] }))
expect(drawing.style.transform).toContain('scale(1.5)')
await userEvent.click(screen.getByRole('button', { name: fr['catalogue.zoom.fit'] }))
expect(drawing.style.transform).toBe('translate(0px, 0px) scale(1)')
// The keyboard on the focused box: + zooms, 0 fits.
fireEvent.keyDown(screen.getByTestId('catalogue-canvas'), { key: '+' })
expect(drawing.style.transform).toContain('scale(1.5)')
fireEvent.keyDown(screen.getByTestId('catalogue-canvas'), { key: '0' })
expect(drawing.style.transform).toBe('translate(0px, 0px) scale(1)')
})
})
describe('failures', () => {
it.each([
[
'a drawing whose bytes do not hash to its row',
() => {
const altered = bytes.slice()
altered[200] ^= 1
fake.storage.download.mockImplementation(async () => ({ data: new Blob([altered]), error: null }))
},
'catalogue.failure.drawing_hash_mismatch',
],
[
'a stored fingerprint the core does not recompute',
() => serveVersions({ [V3]: versionAnswer(V3, 'published', { fingerprint: 'a'.repeat(64) }) }),
'catalogue.failure.fingerprint_mismatch',
],
[
'a drawing Storage does not give',
() =>
fake.storage.download.mockImplementation(async () => ({ data: null, error: { status: 400, name: 'StorageApiError' } })),
'catalogue.failure.drawing_missing',
],
[
'an unreadable document',
() => serveVersions({ [V3]: versionAnswer(V3, 'published', { document: { schema_version: 2 } }) }),
'catalogue.failure.invalid_document',
],
])('names %s', async (_case, arrange, key) => {
arrange()
mount(`/app/anatomy/${SHEET}`)
expect(await screen.findByText(fr[key])).toBeInTheDocument()
expect(screen.getByRole('button', { name: fr['common.retry'] })).toBeInTheDocument()
})
it('folds server and core kinds into the closed page kinds', () => {
expect(serverFailure(new SheetFailure('rights.catalog'))).toBe('denied')
expect(serverFailure(new SheetFailure('not_found'))).toBe('denied')
expect(serverFailure(new SheetFailure('network'))).toBe('network')
expect(serverFailure(new SheetFailure('draft_conflict'))).toBe('unavailable')
expect(coreFailure('caps')).toBe('caps')
expect(coreFailure('internal')).toBe('core_unavailable')
expect(coreFailure('invalid_json')).toBe('invalid_document')
})
it('a freed preview never rebuilds its handle', () => {
const preview = new CataloguePreview(
coreRuntime(),
{ status: 'published', document: JSON.stringify(document), fingerprint },
[{ assetId, sha256, bytes }],
)
const state = preview.state()
expect(state.ok && (state.value as PreviewState).status).toBe('published')
preview.free()
expect(preview.canvas('main')).toEqual({ ok: false, kind: 'core_unavailable' })
})
})
describe('catalogue cards (R4, board 30)', () => {
type Rpc = { rpc: (name: string, args?: unknown) => Promise<unknown> }
afterEach(() => vi.restoreAllMocks())
async function card(name: string): Promise<HTMLElement> {
return (await screen.findByRole('heading', { level: 2, name })).closest('article')!
}
/** The element carrying the notice's tone classes around a line of text. */
function noticeOf(text: HTMLElement): HTMLElement {
return text.closest('div.rounded-lg')!
}
function versionCalls(id: string): number {
return fake.rpcCalls.filter(
([n, a]) => n === 'get_sheet_version' && (a as { version_id: string }).version_id === id,
).length
}
/** Every `get_sheet_version` fails as a dropped request would. */
function failNetwork() {
fake.rpcResults.get_sheet_version = () => ({ error: { message: 'network' } })
}
/** Holds every later `get_sheet_version` answer until the returned release is called. */
function holdVersions(): () => void {
let release!: () => void
const gate = new Promise<void>((resolve) => (release = resolve))
const target = fake.client as unknown as Rpc
const original = target.rpc
target.rpc = async (name, args) => {
if (name === 'get_sheet_version') await gate
return original(name, args)
}
return release
}
async function failedCheval(text: string): Promise<HTMLElement> {
const cheval = await card('Cheval')
await within(cheval).findByText(text)
return cheval
}
it.each([
[
'a drawing whose bytes do not hash to its row',
() => {
const altered = bytes.slice()
altered[200] ^= 1
fake.storage.download.mockImplementation(async () => ({ data: new Blob([altered]), error: null }))
},
],
[
'a stored fingerprint the core does not recompute',
() => serveVersions({ [V3]: versionAnswer(V3, 'published', { fingerprint: 'a'.repeat(64) }) }),
],
[
'a drawing Storage answers 400 for',
() =>
fake.storage.download.mockImplementation(async () => ({ data: null, error: { status: 400, name: 'StorageApiError' } })),
],
[
'a drawing Storage answers 404 for',
() =>
fake.storage.download.mockImplementation(async () => ({ data: null, error: { status: 404, name: 'StorageApiError' } })),
],
[
'an unreadable document',
() => serveVersions({ [V3]: versionAnswer(V3, 'published', { document: { schema_version: 2 } }) }),
],
])('says the integrity failure of %s, without retry or live region', async (_case, arrange) => {
arrange()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.card.integrity_failed'])
expect(noticeOf(within(cheval).getByText(fr['catalogue.card.integrity_failed'])).className).toMatch(
/color-danger/,
)
expect(within(cheval).queryByRole('alert')).toBeNull()
expect(within(cheval).queryByRole('status')).toBeNull()
expect(within(cheval).queryByRole('button', { name: fr['common.retry'] })).toBeNull()
expect(within(cheval).getByRole('link', { name: 'Consulter Cheval' })).toHaveAttribute('href', `/app/anatomy/${SHEET}`)
expect(within(cheval).getByText(fr['catalogue.status.published'])).toBeInTheDocument()
expect(cheval.querySelector('img')).toBeNull()
})
it('says a network failure, retries that card and moves the focus to « Consulter »', async () => {
failNetwork()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.network'])
expect(noticeOf(within(cheval).getByText(fr['catalogue.failure.network'])).className).toMatch(
/severity-moderate/,
)
const retries = within(cheval).getAllByRole('button', { name: fr['common.retry'] })
expect(retries).toHaveLength(1)
serveVersions({ [V3]: versionAnswer(V3, 'published') })
await userEvent.click(retries[0])
expect(await within(cheval).findByText(/2 vues, 27 zones de constats/)).toBeInTheDocument()
expect(within(cheval).queryByText(fr['catalogue.failure.network'])).toBeNull()
expect(within(cheval).getByRole('link', { name: 'Consulter Cheval' })).toHaveFocus()
})
it('keeps « Réessayer » focused during an attempt that fails again, then says the line politely', async () => {
failNetwork()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.network'])
const polite = cheval.querySelector('[aria-live="polite"]')!
expect(polite).toHaveTextContent('')
const release = holdVersions()
const retry = within(cheval).getByRole('button', { name: fr['common.retry'] })
await userEvent.click(retry)
expect(retry).toHaveFocus()
expect(retry).toHaveAttribute('aria-disabled', 'true')
// The attempt is seen, not only told: greyed with a wait cursor (no new wording).
expect(retry.className).toMatch(/aria-disabled:opacity-60/)
expect(retry.className).toMatch(/aria-disabled:cursor-wait/)
expect(cheval).toHaveAttribute('aria-busy', 'true')
expect(polite).toHaveTextContent('')
await act(async () => release())
await waitFor(() => expect(polite).toHaveTextContent(fr['catalogue.failure.network']))
expect(retry).toBeInTheDocument()
expect(retry).toHaveFocus()
expect(retry).not.toHaveAttribute('aria-disabled', 'true')
expect(cheval).not.toHaveAttribute('aria-busy', 'true')
})
it('reloads only the card whose « Réessayer » was pressed, with no burst of announcements', async () => {
failNetwork()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.network'])
const dog = await card('Chien, rachis')
await within(dog).findByText(fr['catalogue.failure.network'])
expect(screen.queryAllByRole('alert')).toHaveLength(0)
expect(within(cheval).queryByRole('status')).toBeNull()
expect(within(dog).queryByRole('status')).toBeNull()
const before = versionCalls(DOG)
const chevalBefore = versionCalls(V3)
await userEvent.click(within(cheval).getByRole('button', { name: fr['common.retry'] }))
const polite = cheval.querySelector('[aria-live="polite"]')!
await waitFor(() => expect(polite).toHaveTextContent(fr['catalogue.failure.network']))
expect(versionCalls(V3)).toBe(chevalBefore + 1)
expect(versionCalls(DOG)).toBe(before)
})
it('ignores a second click while the attempt runs', async () => {
failNetwork()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.network'])
const release = holdVersions()
const before = versionCalls(V3)
const retry = within(cheval).getByRole('button', { name: fr['common.retry'] })
await userEvent.click(retry)
await userEvent.click(retry)
await act(async () => release())
const polite = cheval.querySelector('[aria-live="polite"]')!
await waitFor(() => expect(polite).toHaveTextContent(fr['catalogue.failure.network']))
expect(versionCalls(V3)).toBe(before + 1)
})
it('moves the focus to « Consulter » and says the line when a retry ends with no retry left', async () => {
failNetwork()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.network'])
const polite = cheval.querySelector('[aria-live="polite"]')!
serveVersions({ [V3]: versionAnswer(V3, 'published', { fingerprint: 'a'.repeat(64) }) })
await userEvent.click(within(cheval).getByRole('button', { name: fr['common.retry'] }))
// The region mounted before the attempt is the one that speaks (never mounted with its text).
await waitFor(() => expect(polite).toHaveTextContent(fr['catalogue.card.integrity_failed']))
expect(polite.isConnected).toBe(true)
expect(within(cheval).queryByRole('button', { name: fr['common.retry'] })).toBeNull()
expect(within(cheval).getByRole('link', { name: 'Consulter Cheval' })).toHaveFocus()
})
it('ignores a second retry call in the same tick', async () => {
vi.spyOn(coreRuntime(), 'ready').mockResolvedValueOnce(false)
const restart = vi.spyOn(coreRuntime(), 'retry')
mount('/app/anatomy')
const cheval = await failedCheval(fr['sheet.core_unavailable'])
const before = versionCalls(V3)
const retry = within(cheval).getByRole('button', { name: fr['sheet.core_retry'] })
act(() => {
fireEvent.click(retry)
fireEvent.click(retry)
})
expect(await within(cheval).findByText(/2 vues, 27 zones de constats/)).toBeInTheDocument()
expect(restart).toHaveBeenCalledTimes(1)
expect(versionCalls(V3)).toBe(before + 1)
})
it('drops a retry still running when the card leaves: no update, URLs and previews balanced', async () => {
failNetwork()
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.network'])
const created = vi.spyOn(URL, 'createObjectURL')
const revoked = vi.spyOn(URL, 'revokeObjectURL')
const built = vi.spyOn(CataloguePreview.prototype, 'state')
const freed = vi.spyOn(CataloguePreview.prototype, 'free')
const errors = vi.spyOn(console, 'error')
const release = holdVersions()
serveVersions({ [V3]: versionAnswer(V3, 'published') })
await userEvent.click(within(cheval).getByRole('button', { name: fr['common.retry'] }))
await userEvent.type(screen.getByRole('searchbox', { name: fr['catalogue.search'] }), 'dog')
expect(screen.queryByRole('heading', { level: 2, name: 'Cheval' })).toBeNull()
await act(async () => release())
await waitFor(() => expect(freed).toHaveBeenCalled())
await act(async () => new Promise((resolve) => setTimeout(resolve, 20)))
expect(built.mock.calls.length).toBeGreaterThan(0)
expect(freed).toHaveBeenCalledTimes(built.mock.calls.length)
expect(created).not.toHaveBeenCalled()
expect(revoked).not.toHaveBeenCalled()
expect(errors).not.toHaveBeenCalled()
})
it('says the core failed to load and restarts it on « Réessayer »', async () => {
vi.spyOn(coreRuntime(), 'ready').mockResolvedValueOnce(false)
const restart = vi.spyOn(coreRuntime(), 'retry')
mount('/app/anatomy')
const cheval = await failedCheval(fr['sheet.core_unavailable'])
await userEvent.click(within(cheval).getByRole('button', { name: fr['sheet.core_retry'] }))
expect(restart).toHaveBeenCalledTimes(1)
expect(await within(cheval).findByText(/2 vues, 27 zones de constats/)).toBeInTheDocument()
expect(within(cheval).queryByText(fr['sheet.core_unavailable'])).toBeNull()
})
it('says the engine stopped for good in the error tone, with no « Réessayer »', async () => {
const setStopped = controlStopped(coreRuntime(), true)
try {
vi.spyOn(coreRuntime(), 'ready').mockResolvedValue(false)
mount('/app/anatomy')
const cheval = await failedCheval(fr['core.stopped'])
expect(noticeOf(within(cheval).getByText(fr['core.stopped'])).className).toMatch(/color-danger/)
expect(within(cheval).queryByRole('button', { name: fr['sheet.core_retry'] })).toBeNull()
expect(within(cheval).getByRole('link', { name: 'Consulter Cheval' })).toBeInTheDocument()
} finally {
act(() => setStopped(false))
}
})
it('restarts the engine and reloads only the card whose « Réessayer » was pressed (R-7)', async () => {
serveVersions({ [V3]: versionAnswer(V3, 'published'), [DOG]: versionAnswer(DOG, 'published') })
vi.spyOn(coreRuntime(), 'ready').mockResolvedValueOnce(false).mockResolvedValueOnce(false)
const restart = vi.spyOn(coreRuntime(), 'retry')
mount('/app/anatomy')
const cheval = await failedCheval(fr['sheet.core_unavailable'])
const dog = await card('Chien, rachis')
await within(dog).findByText(fr['sheet.core_unavailable'])
const dogCalls = versionCalls(DOG)
await userEvent.click(within(cheval).getByRole('button', { name: fr['sheet.core_retry'] }))
expect(await within(cheval).findByText(/2 vues, 27 zones de constats/)).toBeInTheDocument()
expect(restart).toHaveBeenCalledTimes(1)
expect(versionCalls(DOG)).toBe(dogCalls)
expect(within(dog).getByText(fr['sheet.core_unavailable'])).toBeInTheDocument()
expect(within(dog).getByRole('button', { name: fr['sheet.core_retry'] })).toBeInTheDocument()
})
it('says an expired session with « Réessayer »', async () => {
fake.rpcResults.get_sheet_version = () => ({ error: { message: 'session_expired' } })
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.session_expired'])
expect(within(cheval).getByRole('button', { name: fr['common.retry'] })).toBeInTheDocument()
})
it('says a refused version read with « Réessayer »', async () => {
mount('/app/anatomy')
const dog = await card('Chien, rachis')
expect(await within(dog).findByText(fr['access_denied.title'])).toBeInTheDocument()
expect(within(dog).getByRole('button', { name: fr['common.retry'] })).toBeInTheDocument()
})
it('says a version over the size limits apart from integrity, without retry (D1)', async () => {
vi.spyOn(CataloguePreview.prototype, 'state').mockReturnValueOnce({ ok: false, kind: 'caps' })
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.caps'])
expect(noticeOf(within(cheval).getByText(fr['catalogue.failure.caps'])).className).toMatch(/color-danger/)
expect(within(cheval).queryByText(fr['catalogue.card.integrity_failed'])).toBeNull()
expect(within(cheval).queryByRole('button', { name: fr['common.retry'] })).toBeNull()
expect(within(cheval).getByRole('link', { name: 'Consulter Cheval' })).toBeInTheDocument()
})
it('says the integrity failure in English', async () => {
useLocaleStore.setState({ locale: 'en' })
serveVersions({ [V3]: versionAnswer(V3, 'published', { fingerprint: 'a'.repeat(64) }) })
mount('/app/anatomy')
const horse = await card('Horse')
expect(await within(horse).findByText(en['catalogue.card.integrity_failed'])).toBeInTheDocument()
})
it('classes every failure kind', () => {
const expected: Record<CatalogueFailure, [integrity: boolean, refused: boolean]> = {
fingerprint_mismatch: [true, true],
drawing_hash_mismatch: [true, true],
drawing_missing: [true, true],
invalid_document: [true, true],
caps: [false, true],
denied: [false, false],
network: [false, false],
session_expired: [false, false],
rate_limited: [false, false],
unavailable: [false, false],
core_unavailable: [false, false],
}
for (const [kind, [integrity, refused]] of Object.entries(expected)) {
const failure = kind as CatalogueFailure
expect(cardFailure(failure, false)).toEqual({ integrity, refused, retry: !refused })
const stoppedRetry = !refused && failure !== 'core_unavailable'
expect(cardFailure(failure, true)).toEqual({ integrity, refused, retry: stoppedRetry })
}
})
it('says a main view the core refuses to compose, with the counts (D2)', async () => {
vi.spyOn(CataloguePreview.prototype, 'canvas').mockReturnValueOnce({ ok: false, kind: 'view_refused' })
mount('/app/anatomy')
const cheval = await failedCheval(fr['catalogue.failure.view'])
const line = noticeOf(within(cheval).getByText(fr['catalogue.failure.view']))
expect(line.className).toMatch(/surface-strong/)
expect(within(cheval).queryByRole('status')).toBeNull()
expect(within(cheval).getByText(/2 vues, 27 zones de constats/)).toBeInTheDocument()
expect(within(cheval).queryByRole('button', { name: fr['common.retry'] })).toBeNull()
expect(cheval.querySelector('img')).toBeNull()
})
it('says the engine failed while composing the main view, with its retry (D2)', async () => {
vi.spyOn(CataloguePreview.prototype, 'canvas').mockReturnValueOnce({ ok: false, kind: 'core_unavailable' })
mount('/app/anatomy')
const cheval = await failedCheval(fr['sheet.core_unavailable'])
expect(within(cheval).getByRole('button', { name: fr['sheet.core_retry'] })).toBeInTheDocument()
})
})