A shown tile the search misses carries « Ne correspond pas à la recherche » under its header (aria-describedby). The no-result notice now needs no shown tile at all. Flip test watchers are stopped in afterEach, so a failing assertion never leaves the setters patched.
710 lines
25 KiB
TypeScript
710 lines
25 KiB
TypeScript
/** R2.3: search, sort, count, no-result notice, A1, the add flow, the pin and the reset. */
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { act, cleanup, render, screen, within } from '@testing-library/react'
|
|
import userEvent from '@testing-library/user-event'
|
|
import type { ReferenceType } from '@faunosteo/core-wasm/types'
|
|
import ReferencesTab from '@/components/editor/tabs/ReferencesTab'
|
|
import { AnnounceContext } from '@/editor/focusRequest'
|
|
import { targetOfKey } from '@/editor/navigation'
|
|
import { useLocaleStore } from '@/state/localeStore'
|
|
import { edit, insert } from '../helpers/editorFixtures'
|
|
import {
|
|
baseText,
|
|
openReady,
|
|
resetStore,
|
|
store,
|
|
} from '../helpers/editorHarness'
|
|
|
|
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(),
|
|
}))
|
|
|
|
beforeEach(() => useLocaleStore.setState({ locale: 'fr' }))
|
|
afterEach(() => {
|
|
cleanup()
|
|
resetStore()
|
|
})
|
|
|
|
const name = (n: string) => ({ fr: n, en: n })
|
|
const ref = (id: string, citation: string, type: ReferenceType) =>
|
|
({
|
|
kind: 'reference',
|
|
value: { id, type, citation, url: null, doi: null },
|
|
}) as const
|
|
|
|
/** Stored order r1..r5; counts r2: 2, r1: 1, r5: 1, r3: 0, r4: 0. */
|
|
function sortText(): string {
|
|
let text = baseText()
|
|
text = insert(text, ref('r1', 'Zèbre 10', 'web'))
|
|
text = insert(text, ref('r2', 'zebre 9', 'journal'))
|
|
text = insert(text, ref('r3', 'Étude', 'book'))
|
|
text = insert(text, ref('r4', 'etude', 'book'))
|
|
text = insert(text, ref('r5', 'Alpha', 'legal'))
|
|
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: ['r1', 'r2', 'r5'],
|
|
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: ['r2'],
|
|
review_status: 'to_confirm',
|
|
children: [],
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
type User = ReturnType<typeof userEvent.setup>
|
|
const doc = () => JSON.parse(store.getState().documentText)
|
|
const lib = (readOnly = false, extra = {}) => (
|
|
<ReferencesTab
|
|
readOnly={readOnly}
|
|
navigate={vi.fn()}
|
|
reloadSheet={vi.fn()}
|
|
{...extra}
|
|
/>
|
|
)
|
|
async function mount(readOnly = false) {
|
|
await openReady({ text: sortText() })
|
|
const user = userEvent.setup()
|
|
const view = render(lib(readOnly))
|
|
return { user, view }
|
|
}
|
|
|
|
const search = () =>
|
|
screen.getByRole('searchbox', { name: 'Rechercher une référence' })
|
|
const sortBox = () => screen.getByLabelText('Trier par')
|
|
/** The ids shown, in display order (header ids `tab-reference-<position>-<id>-header`). */
|
|
const order = () =>
|
|
[...document.querySelectorAll('button[id$="-header"]')].map((button) =>
|
|
button.id.replace(/^tab-reference-\d+-(.*)-header$/, '$1'),
|
|
)
|
|
const header = (id: string) =>
|
|
document.querySelector<HTMLElement>(`button[id$="-${id}-header"]`)!
|
|
const snapshot = () => ({
|
|
text: store.getState().documentText,
|
|
history: store.getState().undo.length,
|
|
unsaved: store.getState().unsaved,
|
|
})
|
|
|
|
describe('the four sorts', () => {
|
|
it('reorder the tiles for display, each stable on ties', async () => {
|
|
const { user } = await mount()
|
|
expect(order()).toEqual(['r1', 'r2', 'r3', 'r4', 'r5'])
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
expect(order()).toEqual(['r5', 'r3', 'r4', 'r2', 'r1'])
|
|
await user.selectOptions(sortBox(), 'count')
|
|
expect(order()).toEqual(['r2', 'r1', 'r5', 'r3', 'r4'])
|
|
await user.selectOptions(sortBox(), 'type')
|
|
expect(order()).toEqual(['r3', 'r4', 'r2', 'r5', 'r1'])
|
|
await user.selectOptions(sortBox(), 'sheet')
|
|
expect(order()).toEqual(['r1', 'r2', 'r3', 'r4', 'r5'])
|
|
})
|
|
|
|
it('offers the four labelled options', async () => {
|
|
await mount()
|
|
const labels = within(sortBox())
|
|
.getAllByRole('option')
|
|
.map((option) => option.textContent)
|
|
expect(labels).toEqual([
|
|
'Ordre de la fiche',
|
|
'Citation (A → Z)',
|
|
'Nombre de citations',
|
|
'Type',
|
|
])
|
|
})
|
|
|
|
it('keep the document, its stored order and the history untouched (BDR-114)', async () => {
|
|
const { user } = await mount()
|
|
const before = snapshot()
|
|
for (const sort of ['citation', 'count', 'type', 'sheet']) {
|
|
await user.selectOptions(sortBox(), sort)
|
|
}
|
|
await user.type(search(), 'zebre')
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
await user.clear(search())
|
|
await user.type(search(), 'zzz')
|
|
await user.click(
|
|
screen.getAllByRole('button', { name: 'Effacer la recherche' })[0],
|
|
)
|
|
expect(snapshot()).toEqual(before)
|
|
expect(doc().references.map((r: { id: string }) => r.id)).toEqual([
|
|
'r1',
|
|
'r2',
|
|
'r3',
|
|
'r4',
|
|
'r5',
|
|
])
|
|
})
|
|
})
|
|
|
|
describe('the count line', () => {
|
|
it('says « {n} références », then « {n} références sur {total} »', async () => {
|
|
const { user } = await mount()
|
|
expect(screen.getByText('5 références')).toBeInTheDocument()
|
|
await user.type(search(), 'zebre')
|
|
expect(screen.getByText('2 références sur 5')).toBeInTheDocument()
|
|
await user.clear(search())
|
|
await user.type(search(), 'alpha')
|
|
expect(screen.getByText('1 référence sur 5')).toBeInTheDocument()
|
|
await user.clear(search())
|
|
await user.type(search(), 'zzz')
|
|
expect(screen.getByText('0 référence sur 5')).toBeInTheDocument()
|
|
})
|
|
})
|
|
|
|
describe('the count with a pinned tile', () => {
|
|
it('counts the matches only, the pinned tile stays shown', async () => {
|
|
const { user } = await mount()
|
|
await startEdit(user, 'r1')
|
|
await user.type(search(), 'alpha')
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
expect(screen.getByText('1 référence sur 5')).toBeInTheDocument()
|
|
})
|
|
})
|
|
|
|
describe('clearing the search', () => {
|
|
it('the button appears with a query, empties it and refocuses the field', async () => {
|
|
const { user } = await mount()
|
|
expect(
|
|
screen.queryByRole('button', { name: 'Effacer la recherche' }),
|
|
).toBeNull()
|
|
await user.type(search(), 'etude')
|
|
expect(order()).toEqual(['r3', 'r4'])
|
|
await user.click(
|
|
screen.getByRole('button', { name: 'Effacer la recherche' }),
|
|
)
|
|
expect(search()).toHaveValue('')
|
|
expect(document.activeElement).toBe(search())
|
|
expect(order()).toHaveLength(5)
|
|
})
|
|
|
|
it('is announced once: the count line is the live region, the notice is not (M11)', async () => {
|
|
const { user } = await mount()
|
|
await user.type(search(), 'radiographie')
|
|
const live = document.querySelectorAll('[aria-live], [role="status"]')
|
|
expect(live).toHaveLength(1)
|
|
expect(live[0]).toHaveTextContent('0 référence sur 5')
|
|
})
|
|
|
|
it('writes the typed text as it is, `$&` and friends included (M5)', async () => {
|
|
const { user } = await mount()
|
|
await user.type(search(), "$& $` $'")
|
|
expect(screen.getByTestId('editor-references-no-result')).toHaveTextContent(
|
|
"Aucune référence ne contient « $& $` $' ».",
|
|
)
|
|
})
|
|
|
|
it('Escape empties a non-empty search and stops there (P12)', async () => {
|
|
const { user } = await mount()
|
|
const bubbled = vi.fn()
|
|
document.body.addEventListener('keydown', bubbled)
|
|
await user.type(search(), 'etude')
|
|
await user.keyboard('{Escape}')
|
|
expect(search()).toHaveValue('')
|
|
expect(bubbled.mock.calls.at(-1)?.[0].defaultPrevented).toBe(true)
|
|
bubbled.mockClear()
|
|
await user.keyboard('{Escape}')
|
|
expect(bubbled).toHaveBeenCalledTimes(1)
|
|
expect(bubbled.mock.calls[0][0].defaultPrevented).toBe(false)
|
|
document.body.removeEventListener('keydown', bubbled)
|
|
})
|
|
})
|
|
|
|
describe('no result (board 24 B)', () => {
|
|
it('shows the notice with its own clear button, and no reorder hint', async () => {
|
|
const { user } = await mount()
|
|
await user.type(search(), 'radiographie')
|
|
expect(order()).toEqual([])
|
|
const notice = screen.getByTestId('editor-references-no-result')
|
|
expect(notice).toHaveTextContent(
|
|
"Aucune référence ne contient « radiographie ». La recherche porte sur la citation, le DOI et l'URL.",
|
|
)
|
|
expect(screen.queryByText(/Pour réorganiser/)).toBeNull()
|
|
await user.click(
|
|
within(notice).getByRole('button', { name: 'Effacer la recherche' }),
|
|
)
|
|
expect(search()).toHaveValue('')
|
|
expect(document.activeElement).toBe(search())
|
|
expect(order()).toHaveLength(5)
|
|
})
|
|
})
|
|
|
|
describe('the move buttons (A1)', () => {
|
|
const movers = () => screen.queryAllByRole('button', { name: 'Descendre' })
|
|
const hint = () => screen.queryByText(/Pour réorganiser, affichez/)
|
|
const openAll = async (user: User) => {
|
|
for (const button of document.querySelectorAll<HTMLElement>(
|
|
'button[id$="-header"]',
|
|
)) {
|
|
await user.click(button)
|
|
}
|
|
}
|
|
|
|
it('exist only in sheet order without a search', async () => {
|
|
const { user } = await mount()
|
|
await openAll(user)
|
|
expect(movers()).toHaveLength(5)
|
|
expect(hint()).toBeNull()
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
expect(movers()).toHaveLength(0)
|
|
expect(hint()).not.toBeNull()
|
|
await user.selectOptions(sortBox(), 'sheet')
|
|
expect(movers()).toHaveLength(5)
|
|
await user.type(search(), 'e')
|
|
expect(movers()).toHaveLength(0)
|
|
expect(hint()).not.toBeNull()
|
|
await user.selectOptions(sortBox(), 'type')
|
|
expect(movers()).toHaveLength(0)
|
|
await user.clear(search())
|
|
expect(movers()).toHaveLength(0)
|
|
expect(hint()).not.toBeNull()
|
|
})
|
|
|
|
it('are absent in read-only, and so is the hint', async () => {
|
|
const { user } = await mount(true)
|
|
await openAll(user)
|
|
await user.selectOptions(sortBox(), 'count')
|
|
expect(movers()).toHaveLength(0)
|
|
expect(hint()).toBeNull()
|
|
expect(
|
|
screen.queryByRole('button', { name: 'Ajouter une référence' }),
|
|
).toBeNull()
|
|
})
|
|
})
|
|
|
|
/** Opens the tile of `id` and enters edit. */
|
|
async function startEdit(user: User, id: string) {
|
|
await user.click(header(id))
|
|
const item = header(id).closest('li')!
|
|
await user.click(within(item).getByRole('button', { name: 'Modifier' }))
|
|
return item
|
|
}
|
|
|
|
describe('the tile in edit is pinned (P23)', () => {
|
|
it('keeps its index when the sort changes', async () => {
|
|
const { user } = await mount()
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
await startEdit(user, 'r1')
|
|
expect(order()).toEqual(['r5', 'r3', 'r4', 'r2', 'r1'])
|
|
await user.selectOptions(sortBox(), 'count')
|
|
expect(order()).toEqual(['r2', 'r5', 'r3', 'r4', 'r1'])
|
|
await user.selectOptions(sortBox(), 'sheet')
|
|
expect(order()).toEqual(['r1', 'r2', 'r3', 'r4', 'r5'])
|
|
})
|
|
|
|
it('starts in sheet order and holds its place under a later sort', async () => {
|
|
const { user } = await mount()
|
|
await startEdit(user, 'r3')
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
expect(order()).toEqual(['r5', 'r4', 'r3', 'r2', 'r1'])
|
|
})
|
|
|
|
it('stays shown under a search that does not match it, also after « Terminer », until the next search change (I1)', async () => {
|
|
const { user } = await mount()
|
|
const item = await startEdit(user, 'r1')
|
|
await user.type(search(), 'alpha')
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
expect(within(item).getByLabelText('Citation')).toBeInTheDocument()
|
|
await user.click(within(item).getByRole('button', { name: 'Terminer' }))
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
expect(document.activeElement).toBe(header('r1'))
|
|
await user.clear(search())
|
|
await user.type(search(), 'alpha')
|
|
expect(order()).toEqual(['r5'])
|
|
})
|
|
|
|
it('keeps the tile shown and focused when its edit stops matching the search (I1)', async () => {
|
|
const { user } = await mount()
|
|
await user.type(search(), 'zèbre')
|
|
const item = await startEdit(user, 'r1')
|
|
const citation = within(item).getByLabelText('Citation')
|
|
await user.clear(citation)
|
|
await user.type(citation, 'Autre titre')
|
|
await user.click(within(item).getByRole('button', { name: 'Terminer' }))
|
|
expect(order()).toEqual(['r1', 'r2'])
|
|
expect(document.activeElement).toBe(header('r1'))
|
|
})
|
|
|
|
it('keeps the tile in edit at its index across a sort change made while read-only (M3)', async () => {
|
|
const { user, view } = await mount()
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
await startEdit(user, 'r3')
|
|
expect(order()).toEqual(['r5', 'r3', 'r4', 'r2', 'r1'])
|
|
view.rerender(lib(true))
|
|
await user.selectOptions(sortBox(), 'count')
|
|
view.rerender(lib(false))
|
|
expect(order()).toEqual(['r2', 'r3', 'r1', 'r5', 'r4'])
|
|
})
|
|
|
|
it('stays pinned in read-only: the read view of the tile, still shown after a search', async () => {
|
|
const { user, view } = await mount()
|
|
await startEdit(user, 'r1')
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
view.rerender(lib(true))
|
|
expect(screen.queryByLabelText('Citation')).toBeNull()
|
|
expect(order()).toEqual(['r1', 'r5', 'r3', 'r4', 'r2'])
|
|
await user.type(search(), 'alpha')
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
view.rerender(lib(false))
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
expect(
|
|
within(header('r1').closest('li')!).getByLabelText('Citation'),
|
|
).toBeVisible()
|
|
})
|
|
|
|
it('a read-only toggle ends the edit state and collapses the tile', async () => {
|
|
const { user, view } = await mount()
|
|
await startEdit(user, 'r1')
|
|
view.rerender(lib(true))
|
|
expect(header('r1')).toHaveAttribute('aria-expanded', 'true')
|
|
await user.click(header('r1'))
|
|
expect(header('r1')).toHaveAttribute('aria-expanded', 'false')
|
|
view.rerender(lib(false))
|
|
expect(header('r1')).toHaveAttribute('aria-expanded', 'false')
|
|
expect(screen.queryByLabelText('Citation')).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('the tile outside the search (C3)', () => {
|
|
const line = 'Ne correspond pas à la recherche'
|
|
const notice = () => screen.queryByTestId('editor-references-no-result')
|
|
const lineOf = (id: string) =>
|
|
within(header(id).closest('li')!).queryByText(line)
|
|
|
|
async function editedOut(user: User) {
|
|
await user.type(search(), 'zèbre')
|
|
const item = await startEdit(user, 'r1')
|
|
const citation = within(item).getByLabelText('Citation')
|
|
await user.clear(citation)
|
|
await user.type(citation, 'Autre titre')
|
|
return item
|
|
}
|
|
|
|
it('after « Terminer » shows the tile with its line, no notice, focus on its header', async () => {
|
|
const { user } = await mount()
|
|
await user.clear(search())
|
|
await user.type(search(), 'alpha')
|
|
const item = await startEdit(user, 'r5')
|
|
await user.clear(within(item).getByLabelText('Citation'))
|
|
await user.type(within(item).getByLabelText('Citation'), 'Autre titre')
|
|
await user.click(within(item).getByRole('button', { name: 'Terminer' }))
|
|
expect(order()).toEqual(['r5'])
|
|
expect(lineOf('r5')).toBeVisible()
|
|
expect(notice()).toBeNull()
|
|
expect(screen.getByText('0 référence sur 5')).toBeInTheDocument()
|
|
expect(document.activeElement).toBe(header('r5'))
|
|
expect(header('r5').getAttribute('aria-describedby')).toBe(lineOf('r5')!.id)
|
|
expect(header('r5')).toHaveAccessibleDescription(line)
|
|
expect(
|
|
screen.getByRole('button', { name: 'Effacer la recherche' }),
|
|
).toBeVisible()
|
|
})
|
|
|
|
it('the next search change drops the tile and shows the notice', async () => {
|
|
const { user } = await mount()
|
|
await user.type(search(), 'alpha')
|
|
const item = await startEdit(user, 'r5')
|
|
await user.clear(within(item).getByLabelText('Citation'))
|
|
await user.type(within(item).getByLabelText('Citation'), 'Autre titre')
|
|
await user.click(within(item).getByRole('button', { name: 'Terminer' }))
|
|
await user.type(search(), 'x')
|
|
expect(order()).toEqual([])
|
|
expect(notice()).not.toBeNull()
|
|
})
|
|
|
|
it('a tile in edit that does not match carries the line', async () => {
|
|
const { user } = await mount()
|
|
const item = await editedOut(user)
|
|
expect(lineOf('r1')).toBeNull()
|
|
await user.type(search(), 'x')
|
|
expect(within(item).getByLabelText('Citation')).toBeVisible()
|
|
expect(lineOf('r1')).toBeVisible()
|
|
})
|
|
|
|
it('a matching pinned tile has no line', async () => {
|
|
const { user } = await mount()
|
|
await startEdit(user, 'r1')
|
|
await user.type(search(), 'alpha')
|
|
expect(lineOf('r1')).toBeVisible()
|
|
expect(lineOf('r5')).toBeNull()
|
|
await user.clear(search())
|
|
expect(lineOf('r1')).toBeNull()
|
|
})
|
|
|
|
it('a read-only flip keeps the tile and its line', async () => {
|
|
const { user, view } = await mount()
|
|
await startEdit(user, 'r1')
|
|
await user.type(search(), 'alpha')
|
|
view.rerender(lib(true))
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
expect(lineOf('r1')).toBeVisible()
|
|
expect(notice()).toBeNull()
|
|
})
|
|
|
|
it('an open draft tile does not hide the notice for a search matching nothing', async () => {
|
|
const { user } = await mount()
|
|
await user.click(
|
|
screen.getByRole('button', { name: 'Ajouter une référence' }),
|
|
)
|
|
await user.type(search(), 'radiographie')
|
|
expect(order()).toEqual([])
|
|
expect(notice()).not.toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('adding (P24)', () => {
|
|
const add = () =>
|
|
screen.getByRole('button', { name: 'Ajouter une référence' })
|
|
const draftCitation = () =>
|
|
document.querySelector<HTMLElement>('#tab-reference-new-citation')
|
|
|
|
it('resets search and sort, appends a draft tile in edit, citation focused', async () => {
|
|
const { user } = await mount()
|
|
await user.selectOptions(sortBox(), 'count')
|
|
await user.type(search(), 'e')
|
|
await user.click(add())
|
|
expect(search()).toHaveValue('')
|
|
expect(sortBox()).toHaveValue('sheet')
|
|
expect(order()).toHaveLength(5)
|
|
expect(document.activeElement).toBe(draftCitation())
|
|
expect(screen.getByLabelText('Type')).toHaveValue('')
|
|
expect(
|
|
within(screen.getByLabelText('Type')).getByText('Choisir…'),
|
|
).toBeInTheDocument()
|
|
expect(
|
|
screen.getByText('Type et citation obligatoires.'),
|
|
).toBeInTheDocument()
|
|
expect(snapshot().history).toBe(0)
|
|
})
|
|
|
|
it('creates the reference in one modification; the tile stays open, out of edit, focused', async () => {
|
|
const { user } = await mount()
|
|
await user.click(add())
|
|
await user.selectOptions(screen.getByLabelText('Type'), 'book')
|
|
await user.type(draftCitation()!, 'Nouvelle source')
|
|
await user.click(
|
|
screen.getByRole('button', { name: 'Ajouter la référence' }),
|
|
)
|
|
expect(store.getState().undo.length).toBe(1)
|
|
expect(doc().references).toHaveLength(6)
|
|
const id = doc().references[5].id
|
|
expect(order()).toHaveLength(6)
|
|
expect(header(id)).toHaveAttribute('aria-expanded', 'true')
|
|
expect(document.activeElement).toBe(header(id))
|
|
expect(draftCitation()).toBeNull()
|
|
expect(
|
|
within(header(id).closest('li')!).getByRole('button', {
|
|
name: 'Modifier',
|
|
}),
|
|
).toBeInTheDocument()
|
|
})
|
|
|
|
it('a search typed after « Ajouter une référence » is cleared by the add, the new tile takes the focus (I1)', async () => {
|
|
const { user } = await mount()
|
|
await user.click(add())
|
|
await user.selectOptions(screen.getByLabelText('Type'), 'book')
|
|
await user.type(draftCitation()!, 'Nouvelle source')
|
|
await user.type(search(), 'alpha')
|
|
expect(order()).toEqual(['r5'])
|
|
await user.click(
|
|
screen.getByRole('button', { name: 'Ajouter la référence' }),
|
|
)
|
|
const id = doc().references[5].id
|
|
expect(search()).toHaveValue('')
|
|
expect(order()).toHaveLength(6)
|
|
expect(document.activeElement).toBe(header(id))
|
|
})
|
|
|
|
it('a second click on the button takes the focus back to the citation', async () => {
|
|
const { user } = await mount()
|
|
await user.click(add())
|
|
await user.click(search())
|
|
await user.click(add())
|
|
expect(document.activeElement).toBe(draftCitation())
|
|
expect(
|
|
document.querySelectorAll('#tab-reference-new-citation'),
|
|
).toHaveLength(1)
|
|
})
|
|
|
|
it('leaves the tile in edit first: a refused field cancels the add (P22)', async () => {
|
|
const { user } = await mount()
|
|
const item = await startEdit(user, 'r1')
|
|
const url = within(item).getByLabelText('Adresse web (URL)')
|
|
await user.type(url, 'exemple.org')
|
|
await user.click(add())
|
|
expect(draftCitation()).toBeNull()
|
|
expect(document.activeElement).toBe(url)
|
|
await user.clear(url)
|
|
await user.click(add())
|
|
expect(draftCitation()).not.toBeNull()
|
|
expect(within(item).queryByLabelText('Citation')).toBeNull()
|
|
})
|
|
|
|
it('keeps the draft hidden in read-only and resumes it when editable again', async () => {
|
|
const { user, view } = await mount()
|
|
await user.click(add())
|
|
await user.type(draftCitation()!, 'En cours')
|
|
view.rerender(lib(true))
|
|
expect(draftCitation()).not.toBeVisible()
|
|
view.rerender(lib(false))
|
|
expect(draftCitation()).toBeVisible()
|
|
expect(draftCitation()).toHaveValue('En cours')
|
|
})
|
|
})
|
|
|
|
describe('the reset path (« Tout afficher »)', () => {
|
|
it('empties the search and the sort, keeping open tiles and the tile in edit', async () => {
|
|
await openReady({ text: sortText() })
|
|
const user = userEvent.setup()
|
|
const view = render(lib(false, { libraryReset: 0 }))
|
|
await user.click(header('r2'))
|
|
const item = await startEdit(user, 'r1')
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
await user.type(search(), 'e')
|
|
view.rerender(lib(false, { libraryReset: 1 }))
|
|
expect(search()).toHaveValue('')
|
|
expect(sortBox()).toHaveValue('sheet')
|
|
expect(order()).toHaveLength(5)
|
|
expect(header('r2')).toHaveAttribute('aria-expanded', 'true')
|
|
expect(within(item).getByLabelText('Citation')).toBeInTheDocument()
|
|
// The tile in edit stays pinned through the reset: a new search does not hide it.
|
|
await user.type(search(), 'alpha')
|
|
expect(order()).toEqual(['r1', 'r5'])
|
|
})
|
|
})
|
|
|
|
describe('« Aller à » a reference hidden by the search (P3, P8)', () => {
|
|
const request = (id: string, serial: number) => ({
|
|
target: targetOfKey({ kind: 'reference', id }),
|
|
serial,
|
|
})
|
|
|
|
it('clears the search only, opens the tile, focuses its button, keeps other tiles open', async () => {
|
|
const { user, view } = await mount()
|
|
await user.click(header('r2'))
|
|
await user.selectOptions(sortBox(), 'citation')
|
|
await user.type(search(), 'alpha')
|
|
await act(async () =>
|
|
view.rerender(lib(false, { focus: request('r3', 1) })),
|
|
)
|
|
expect(search()).toHaveValue('')
|
|
expect(sortBox()).toHaveValue('citation')
|
|
expect(header('r3')).toHaveAttribute('aria-expanded', 'true')
|
|
expect(header('r2')).toHaveAttribute('aria-expanded', 'true')
|
|
expect(document.activeElement).toBe(header('r3'))
|
|
})
|
|
|
|
it('keeps a search that does not hide it', async () => {
|
|
const { user, view } = await mount()
|
|
await user.type(search(), 'etude')
|
|
await act(async () =>
|
|
view.rerender(lib(false, { focus: request('r4', 1) })),
|
|
)
|
|
expect(search()).toHaveValue('etude')
|
|
expect(document.activeElement).toBe(header('r4'))
|
|
expect(header('r4')).toHaveAttribute('aria-expanded', 'true')
|
|
})
|
|
})
|
|
|
|
describe('state of a reference that left the document (P23-prime)', () => {
|
|
it('is dropped: undoing the removal brings the tile back closed and out of edit', async () => {
|
|
const { user } = await mount()
|
|
await startEdit(user, 'r4')
|
|
act(() => {
|
|
store
|
|
.getState()
|
|
.commit({ op: 'remove', key: { kind: 'reference', id: 'r4' } })
|
|
})
|
|
expect(order()).toEqual(['r1', 'r2', 'r3', 'r5'])
|
|
act(() => {
|
|
store.getState().undoStep()
|
|
})
|
|
expect(order()).toContain('r4')
|
|
expect(header('r4')).toHaveAttribute('aria-expanded', 'false')
|
|
expect(
|
|
within(header('r4').closest('li')!).queryByLabelText('Citation'),
|
|
).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('a read-only flip with a tile in edit (M1)', () => {
|
|
const ui = (announce: (text: string) => void, readOnly: boolean) => (
|
|
<AnnounceContext value={announce}>{lib(readOnly)}</AnnounceContext>
|
|
)
|
|
|
|
async function refusedUrl() {
|
|
await openReady({ text: sortText() })
|
|
const user = userEvent.setup()
|
|
const announce = vi.fn()
|
|
const view = render(ui(announce, false))
|
|
const item = await startEdit(user, 'r1')
|
|
await user.type(
|
|
within(item).getByLabelText('Adresse web (URL)'),
|
|
'exemple.org',
|
|
)
|
|
await user.tab()
|
|
return { view, announce, item, user }
|
|
}
|
|
|
|
it('says which refused draft is dropped, once', async () => {
|
|
const { view, announce } = await refusedUrl()
|
|
view.rerender(ui(announce, true))
|
|
expect(announce).toHaveBeenCalledTimes(1)
|
|
expect(announce).toHaveBeenCalledWith(
|
|
'Saisie non appliquée : Adresse web (URL)',
|
|
)
|
|
view.rerender(ui(announce, false))
|
|
expect(announce).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('does not move the focus to Citation when editing is possible again', async () => {
|
|
const { view, announce } = await refusedUrl()
|
|
view.rerender(ui(announce, true))
|
|
view.rerender(ui(announce, false))
|
|
const citation = screen.getByLabelText('Citation')
|
|
expect(document.activeElement).not.toBe(citation)
|
|
expect(screen.getByLabelText('Adresse web (URL)')).toHaveValue('')
|
|
})
|
|
|
|
it('says nothing when no draft is lost', async () => {
|
|
await openReady({ text: sortText() })
|
|
const user = userEvent.setup()
|
|
const announce = vi.fn()
|
|
const view = render(ui(announce, false))
|
|
await startEdit(user, 'r1')
|
|
view.rerender(ui(announce, true))
|
|
expect(announce).not.toHaveBeenCalled()
|
|
})
|
|
})
|