test(editor): reference dialog, filter and the owner journey, specs follow the dialog

This commit is contained in:
bchanot committed 2026-11-13 20:27:01 +01:00
1 parent 7a64daf251
commit 8b42816270
20 files changed
+1546 -1171

No files matched your search

@@ -0,0 +1,534 @@
/** R2F-5 and R2F-6: the reference dialog, the reading tiles, the finding filter, their history. */
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
act,
cleanup,
fireEvent,
screen,
waitFor,
within,
} from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import type { Location, NavigateFunction } from 'react-router-dom'
import { ENTRY_KEY, type HistoryEntry } from '@/editor/history/entry'
import { useLocaleStore } from '@/state/localeStore'
import { edit, insert } from '../helpers/editorFixtures'
import {
baseText,
resetStore,
serverHas,
store,
} from '../helpers/editorHarness'
import { mountDraft, setWidth } from '../helpers/editorRoute'
import { findingDialog, openFinding } from '../helpers/findingDialog'
vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
vi.mock('@faunosteo/supabase', async (orig) => ({
...(await orig<typeof import('@faunosteo/supabase')>()),
getSheetVersion: vi.fn(),
downloadSheetDrawing: vi.fn(),
saveSheetDraft: vi.fn(),
getOfficialSheetAdmin: vi.fn(),
submitSheetReview: vi.fn(),
}))
let navigate: NavigateFunction
let location: Location
const probe = (n: NavigateFunction, l: Location) => {
navigate = n
location = l
}
const written = () =>
(location.state as Record<string, HistoryEntry> | null)?.[ENTRY_KEY]
const back = () => act(async () => navigate(-1))
beforeEach(() => useLocaleStore.setState({ locale: 'fr' }))
afterEach(() => {
cleanup()
resetStore()
setWidth(1024)
})
const name = (n: string) => ({ fr: n, en: n })
const ref = (id: string, citation: string, url = '') =>
({
kind: 'reference',
value: { id, type: 'book', citation, url: url || null, doi: null },
}) as const
/** Three references; Node A (under Cat A) cites ref-a and ref-b. */
function sheetText(): string {
let text = baseText()
text = insert(text, ref('ref-a', 'Barone, Ostéologie'))
text = insert(text, ref('ref-b', 'Denoix', 'https://exemple.org/p'))
text = insert(text, ref('ref-c', 'Code rural'))
text = insert(text, {
kind: 'zone',
value: { id: 'zone-a', name: name('Zone A'), categories: [] },
})
text = edit(text, {
op: 'insert',
parent: { kind: 'zone', id: 'zone-a' },
element: {
kind: 'finding_category',
value: {
id: 'fcat-a',
kind: 'dysfunction',
name: name('Cat A'),
description: {},
reference_ids: [],
review_status: 'to_confirm',
children: [],
},
},
})
return edit(text, {
op: 'insert',
parent: { kind: 'finding', zone_id: 'zone-a', path: ['fcat-a'] },
element: {
kind: 'finding_node',
value: {
id: 'fnode-a',
name: name('Node A'),
description: {},
requires_vet_referral: false,
reference_ids: ['ref-a', 'ref-b'],
review_status: 'to_confirm',
children: [],
},
},
})
}
type User = ReturnType<typeof userEvent.setup>
async function mount(width = 1280): Promise<User> {
serverHas(sheetText(), 3)
const user = userEvent.setup()
mountDraft({ width, probe })
await screen.findByRole('heading', { level: 1, name: 'Brouillon, version 4' })
await user.click(screen.getByRole('tab', { name: 'Références' }))
await waitFor(() => expect(written()?.view.tab).toBe('references'))
return user
}
const doc = () => JSON.parse(store.getState().documentText)
const entries = () => store.getState().undo.length
const dialogs = () => document.querySelectorAll('dialog[open]')
const refDialog = () =>
[...dialogs()].find((d) => d.querySelector('[data-draft-form]')) as
| HTMLElement
| undefined
const inRef = () => within(refDialog()!)
const closed = () => waitFor(() => expect(refDialog()).toBeUndefined())
const tab = () => screen.getByRole('tabpanel', { name: 'Références' })
const header = (citation: string) =>
within(tab()).getByRole('button', { name: new RegExp(`^${citation}`) })
const modify = async (user: User, citation: string) => {
if (header(citation).getAttribute('aria-expanded') === 'false') {
await user.click(header(citation))
}
const tile = header(citation).closest('li')!
await user.click(within(tile).getByRole('button', { name: 'Modifier' }))
await waitFor(() => expect(refDialog()).toBeDefined())
}
const field = (label: string) => inRef().getByLabelText(label)
const save = (user: User) =>
user.click(
inRef().getByRole('button', {
name: /^(Enregistrer|Ajouter la référence)$/,
}),
)
const live = () => document.querySelector('p.sr-only[aria-live="polite"]')!
describe('the dialog', () => {
it('opens from « Modifier » with the first control focused, one entry on top', async () => {
const user = await mount()
const first = written()!.id
await modify(user, 'Barone')
expect(
inRef().getByRole('heading', { name: 'Modifier la référence' }),
).toBeVisible()
expect(refDialog()!.contains(document.activeElement)).toBe(true)
expect(field('Citation')).toHaveValue('Barone, Ostéologie')
await waitFor(() => expect(written()?.id).not.toBe(first))
expect(written()?.view.reference).toEqual({ edit: 'ref-a' })
expect(written()?.below?.reference).toBeNull()
})
it('a pristine « Enregistrer » closes with no command; a changed one is one entry', async () => {
const user = await mount()
await modify(user, 'Barone')
const before = entries()
await save(user)
await closed()
expect(entries()).toBe(before)
await modify(user, 'Barone')
await user.type(field('DOI'), '10.1000/x')
await user.clear(field('Citation'))
await user.type(field('Citation'), 'Neuf')
await user.type(field('Adresse web (URL)'), 'https://a.org/')
await save(user)
await closed()
expect(entries()).toBe(before + 1)
expect(doc().references[0]).toMatchObject({
citation: 'Neuf',
doi: '10.1000/x',
url: 'https://a.org/',
})
act(() => void store.getState().undoStep())
expect(doc().references[0]).toMatchObject({
citation: 'Barone, Ostéologie',
doi: null,
url: null,
})
})
it('a double click on « Enregistrer » writes once and pops at most one entry', async () => {
const user = await mount()
const mounted = written()!.id
await modify(user, 'Barone')
await user.clear(field('Citation'))
await user.type(field('Citation'), 'Neuf')
const button = inRef().getByRole('button', { name: 'Enregistrer' })
fireEvent.click(button)
fireEvent.click(button)
await closed()
expect(entries()).toBe(1)
await waitFor(() => expect(written()?.id).toBe(mounted))
})
it('a blank citation and a non-http address are refused on their field', async () => {
const user = await mount()
await modify(user, 'Barone')
await user.clear(field('Citation'))
await save(user)
expect(field('Citation')).toHaveFocus()
expect(field('Citation')).toHaveAccessibleDescription(
'Ce champ est obligatoire.',
)
await user.type(field('Citation'), 'Barone')
await user.type(field('Adresse web (URL)'), 'exemple.org')
await save(user)
expect(field('Adresse web (URL)')).toHaveFocus()
expect(field('Adresse web (URL)')).toHaveAccessibleDescription(
/http:\/\/ ou https:\/\//,
)
expect(entries()).toBe(0)
expect(refDialog()).toBeDefined()
})
it('« Annuler » with changes asks, « Abandonner » writes nothing', async () => {
const user = await mount()
await modify(user, 'Barone')
await user.type(field('DOI'), '10.1/x')
await user.click(inRef().getByRole('button', { name: 'Annuler' }))
expect(inRef().getByText('Abandonner les modifications ?')).toBeVisible()
expect(
inRef().getByRole('button', { name: 'Continuer la saisie' }),
).toHaveFocus()
await user.click(
inRef().getByRole('button', { name: 'Continuer la saisie' }),
)
expect(field('DOI')).toHaveValue('10.1/x')
await user.click(inRef().getByRole('button', { name: 'Annuler' }))
await user.click(inRef().getByRole('button', { name: 'Abandonner' }))
await closed()
expect(entries()).toBe(0)
})
it('a real dialog.close() on a dirty dialog keeps it, with its confirmation', async () => {
const user = await mount()
await modify(user, 'Barone')
await user.type(field('DOI'), '10.1/x')
act(() => (refDialog() as HTMLDialogElement).close())
await waitFor(() =>
expect(inRef().getByText('Abandonner les modifications ?')).toBeVisible(),
)
expect(refDialog()!.hasAttribute('open')).toBe(true)
expect(field('DOI')).toHaveValue('10.1/x')
})
it('Escape asks once when dirty; a held Escape (repeat) is ignored', async () => {
const user = await mount()
await modify(user, 'Barone')
await user.type(field('DOI'), '10.1/x')
fireEvent.keyDown(field('DOI'), { key: 'Escape', repeat: true })
expect(inRef().queryByText('Abandonner les modifications ?')).toBeNull()
fireEvent.keyDown(field('DOI'), { key: 'Escape' })
expect(inRef().getByText('Abandonner les modifications ?')).toBeVisible()
})
it('Défaire is unreachable under the dialog and a mode flip leaves the draft untouched', async () => {
const user = await mount()
await modify(user, 'Barone')
await user.type(field('DOI'), '10.1/x')
fireEvent.keyDown(document.body, { key: 'z', ctrlKey: true })
expect(field('DOI')).toHaveValue('10.1/x')
const same = field('DOI')
act(() => {
setWidth(900)
window.dispatchEvent(new Event('resize'))
})
expect(field('DOI')).toBe(same)
expect(same).toHaveAttribute('readonly')
expect(inRef().getByText(/Élargissez la fenêtre/)).toBeVisible()
expect(inRef().getByRole('button', { name: 'Enregistrer' })).toBeDisabled()
expect(entries()).toBe(0)
act(() => {
setWidth(1280)
window.dispatchEvent(new Event('resize'))
})
expect(same).not.toHaveAttribute('readonly')
expect(same).toHaveValue('10.1/x')
})
it('a reference that vanishes closes its dialog by replace and says so', async () => {
const user = await mount()
await modify(user, 'Code rural')
const open = written()!
act(() => {
store
.getState()
.commit({ op: 'remove', key: { kind: 'reference', id: 'ref-c' } })
})
await closed()
await waitFor(() =>
expect(live()).toHaveTextContent("Cette référence n'existe plus"),
)
expect(written()?.id).toBe(open.id)
expect(written()?.view.reference).toBeNull()
})
})
describe('creation', () => {
const add = () =>
screen.getByRole('button', { name: 'Ajouter une référence' })
it('needs a type and a citation, creates in one command, leaves the list and says so', async () => {
const user = await mount()
await user.click(add())
await waitFor(() => expect(refDialog()).toBeDefined())
expect(written()?.view.reference).toEqual({ create: true })
await save(user)
expect(field('Type')).toHaveFocus()
await user.selectOptions(field('Type'), 'book')
await user.type(field('Citation'), 'Nouvelle source')
await save(user)
await closed()
expect(entries()).toBe(1)
expect(doc().references).toHaveLength(4)
// Appended after the three, the sheet order untouched: nothing moved.
expect(within(tab()).getAllByRole('listitem')).toHaveLength(4)
expect(
within(tab()).getByText('Référence ajoutée : Nouvelle source'),
).toBeVisible()
await waitFor(() =>
expect(live()).toHaveTextContent('Référence ajoutée : Nouvelle source'),
)
expect(add()).toHaveFocus()
})
it('« Afficher » shows the new tile open and focuses it', async () => {
const user = await mount()
await user.click(add())
await waitFor(() => expect(refDialog()).toBeDefined())
await user.selectOptions(field('Type'), 'book')
await user.type(field('Citation'), 'Nouvelle source')
await save(user)
await closed()
await user.click(within(tab()).getByRole('button', { name: 'Afficher' }))
expect(within(tab()).queryByText(/Référence ajoutée/)).toBeNull()
await waitFor(() =>
expect(header('Nouvelle source')).toHaveAttribute(
'aria-expanded',
'true',
),
)
await waitFor(() => expect(header('Nouvelle source')).toHaveFocus())
})
it('the entry becomes the reference’s own: Back, then Forward, reopens an edit, never a creation', async () => {
const user = await mount()
const first = written()!.id
await user.click(add())
await waitFor(() =>
expect(written()?.view.reference).toEqual({ create: true }),
)
const entry = written()!.id
await user.selectOptions(field('Type'), 'book')
await user.type(field('Citation'), 'Nouvelle source')
await save(user)
await closed()
await waitFor(() => expect(written()?.id).toBe(first))
await act(async () => navigate(1))
await waitFor(() => expect(written()?.id).toBe(entry))
const created = doc().references[3].id
expect(written()?.view.reference).toEqual({ edit: created })
})
it('a dirty creation asks before it closes and writes nothing', async () => {
const user = await mount()
await user.click(add())
await waitFor(() => expect(refDialog()).toBeDefined())
await user.type(field('Citation'), 'x')
await user.keyboard('{Escape}')
await user.click(inRef().getByRole('button', { name: 'Abandonner' }))
await closed()
expect(entries()).toBe(0)
await waitFor(() => expect(add()).toHaveFocus())
})
})
describe('history', () => {
it('Back closes the dialog and the opener holds the focus; Forward reopens it', async () => {
const user = await mount()
await modify(user, 'Barone')
const opener = within(header('Barone').closest('li')!).getByRole('button', {
name: 'Modifier',
})
await back()
await closed()
await waitFor(() => expect(opener).toHaveFocus())
await act(async () => navigate(1))
await waitFor(() => expect(refDialog()).toBeDefined())
expect(field('Citation')).toHaveValue('Barone, Ostéologie')
})
it('a dirty dialog keeps its draft when Back asks, then Abandonner pops once', async () => {
const user = await mount()
await modify(user, 'Barone')
await user.type(field('DOI'), '10.1/x')
await back()
expect(inRef().getByText('Abandonner les modifications ?')).toBeVisible()
fireEvent.click(
inRef().getByRole('button', { name: 'Continuer la saisie' }),
)
expect(field('DOI')).toHaveValue('10.1/x')
fireEvent.click(inRef().getByRole('button', { name: 'Annuler' }))
await user.click(inRef().getByRole('button', { name: 'Abandonner' }))
await closed()
await waitFor(() => expect(written()?.view.reference).toBeNull())
expect(entries()).toBe(0)
}, 20_000)
it('a reload keeps the tab but never reopens the form', async () => {
const user = await mount()
await modify(user, 'Barone')
const entry = written()!
cleanup()
serverHas(sheetText(), 3)
mountDraft({
probe,
entries: [{ pathname: location.pathname, state: { [ENTRY_KEY]: entry } }],
})
await screen.findByRole('heading', {
level: 1,
name: 'Brouillon, version 4',
})
await waitFor(() => expect(written()?.view.reference).toBeNull())
expect(written()?.view.tab).toBe('references')
expect(refDialog()).toBeUndefined()
})
})
describe('the finding filter', () => {
const chip = () => screen.getByTestId('editor-references-filter')
/** Node A's dialog, its sheet, then « Tout afficher »: the tab filtered by Node A. */
async function filtered(user: User) {
await user.click(screen.getByRole('tab', { name: 'Constats' }))
await openFinding(user, /Node A/)
await user.click(screen.getByRole('button', { name: '2 références' }))
await user.click(
await screen.findByRole('button', {
name: "Tout afficher dans l'onglet Références",
}),
)
await waitFor(() => expect(written()?.view.tab).toBe('references'))
}
it('« Tout afficher » lists the finding’s references, counts within the filter, no reorder', async () => {
const user = await mount()
await filtered(user)
expect(written()?.view.referenceFilter).toMatchObject({ kind: 'finding' })
expect(chip()).toHaveTextContent('Références du constat : Node A')
expect(within(tab()).getAllByRole('listitem')).toHaveLength(2)
expect(within(tab()).getByText('2 références')).toBeVisible()
await user.click(header('Barone'))
expect(
within(tab()).queryByRole('button', { name: 'Descendre' }),
).toBeNull()
await user.type(
within(tab()).getByRole('searchbox', {
name: 'Rechercher une référence',
}),
'Code',
)
expect(within(tab()).getByText('0 référence sur 2')).toBeVisible()
expect(screen.getByTestId('editor-references-no-result')).toBeVisible()
})
it('the × removes the filter by replace; the search text is never in the entry', async () => {
const user = await mount()
await filtered(user)
const id = written()!.id
await user.type(
within(tab()).getByRole('searchbox', {
name: 'Rechercher une référence',
}),
'Code',
)
await user.click(
within(chip()).getByRole('button', {
name: 'Retirer le filtre du constat Node A',
}),
)
await waitFor(() => expect(written()?.view.referenceFilter).toBeNull())
expect(written()?.id).toBe(id)
expect(JSON.stringify(location.state)).not.toContain('Code')
expect(within(tab()).getAllByRole('listitem').length).toBeGreaterThan(0)
})
it('« Revenir au constat » pops to the finding with its sheet open when the entry below shows it', async () => {
const user = await mount()
await filtered(user)
await user.click(screen.getByRole('button', { name: 'Revenir au constat' }))
await waitFor(() => expect(dialogs()).toHaveLength(2))
expect(written()?.view.finding).toMatchObject({ citations: true })
expect(written()?.view.referenceFilter).toBeNull()
})
it('a finding that vanishes clears the filter and says so', async () => {
const user = await mount()
await filtered(user)
act(() => {
store.getState().commit({
op: 'remove',
key: {
kind: 'finding',
zone_id: 'zone-a',
path: ['fcat-a', 'fnode-a'],
},
})
})
await waitFor(() => expect(written()?.view.referenceFilter).toBeNull())
expect(screen.queryByTestId('editor-references-filter')).toBeNull()
await waitFor(() =>
expect(live()).toHaveTextContent(
"Le constat n'existe plus : le filtre est retiré",
),
)
})
it('the finding dialog and the sheet come back by Back, the filtered tab by Forward', async () => {
const user = await mount()
await filtered(user)
await back()
await waitFor(() => expect(dialogs()).toHaveLength(2))
expect(findingDialog()).not.toBeNull()
await act(async () => navigate(1))
await waitFor(() => expect(dialogs()).toHaveLength(0))
expect(chip()).toBeVisible()
})
})