test(editor): reference dialog, filter and the owner journey, specs follow the dialog
This commit is contained in:
1 parent
7a64daf251
commit
8b42816270
20 files changed
+1546
-1171
No files matched your search
@@ -19,6 +19,8 @@ import {
|
||||
openFinding,
|
||||
openTab,
|
||||
place,
|
||||
referenceDialog,
|
||||
referenceSettled,
|
||||
saveDraft,
|
||||
seedDraft,
|
||||
serverDocument,
|
||||
@@ -251,9 +253,13 @@ test.describe('citations sheet, editing', () => {
|
||||
await expect(
|
||||
root.getByRole('button', { name: /Source B/ }),
|
||||
).toHaveAttribute('aria-expanded', 'true')
|
||||
// Filtered by the finding the sheet belonged to: its three citations (R2F-6).
|
||||
await expect(
|
||||
root.locator('button[aria-controls][id$="-header"]'),
|
||||
).toHaveCount(4)
|
||||
).toHaveCount(3)
|
||||
await expect(root.getByTestId('editor-references-filter')).toContainText(
|
||||
'Constat A',
|
||||
)
|
||||
// The move is an entry of its own: Back returns to the finding with its sheet on top.
|
||||
await page.goBack()
|
||||
await expect(place(page, 'citations')).toBeVisible()
|
||||
@@ -264,26 +270,42 @@ test.describe('citations sheet, editing', () => {
|
||||
await expect(place(page, 'references')).toBeVisible()
|
||||
})
|
||||
|
||||
test('Escape in a field of a tile neither closes the sheet nor commits; ✕ then commits', async ({
|
||||
test('« Modifier » opens the reference dialog over the sheet; « Enregistrer » closes it only, one undo', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
const { seed } = await open(page)
|
||||
await openCitations(page, dict, 'Constat A')
|
||||
await heads(page).first().click()
|
||||
await panel(page)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
const field = panel(page).getByLabel(dict['editor.reference.citation'])
|
||||
const modify = panel(page).getByRole('button', {
|
||||
name: dict['editor.references.edit'],
|
||||
})
|
||||
await modify.click()
|
||||
await expect(referenceDialog(page)).toBeVisible()
|
||||
await expect(page.locator('dialog[open]')).toHaveCount(3)
|
||||
const field = referenceDialog(page).getByLabel(
|
||||
dict['editor.reference.citation'],
|
||||
)
|
||||
await field.fill('Référence A, révisée')
|
||||
// Escape asks (the draft is kept), it neither closes the sheet nor writes.
|
||||
await field.press('Escape')
|
||||
await expect(panel(page)).toBeVisible()
|
||||
await expect(field).toHaveValue('Référence A, révisée')
|
||||
// A user close applies a valid draft first (P22''), then the sheet exits.
|
||||
await panel(page)
|
||||
.getByRole('button', { name: dict['editor.references.close'] })
|
||||
await expect(
|
||||
referenceDialog(page).getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await expect(page.locator('dialog[open]')).toHaveCount(3)
|
||||
await referenceDialog(page)
|
||||
.getByRole('button', { name: dict['editor.findings.keep_typing'] })
|
||||
.click()
|
||||
await expect(panel(page)).toHaveCount(0)
|
||||
await expect(field).toHaveValue('Référence A, révisée')
|
||||
await referenceDialog(page)
|
||||
.getByRole('button', { name: dict['editor.findings.save'] })
|
||||
.click()
|
||||
await expect(referenceDialog(page)).toHaveCount(0)
|
||||
await referenceSettled(page)
|
||||
await expect(panel(page)).toBeVisible()
|
||||
await expect(page.locator('dialog[open]')).toHaveCount(2)
|
||||
await expect(modify).toBeFocused()
|
||||
await closeCitations(page, dict)
|
||||
await closeFinding(page, dict)
|
||||
await expect(undo(page)).toBeEnabled()
|
||||
await saveDraft(page, dict, seed.revision + 1)
|
||||
@@ -293,7 +315,7 @@ test.describe('citations sheet, editing', () => {
|
||||
expect(saved.references[0].citation).toBe('Référence A, révisée')
|
||||
})
|
||||
|
||||
test('a refused draft cancels every move that unmounts the sheet: ✕, scrim, Back, « Tout afficher »', async ({
|
||||
test('a dirty reference dialog keeps its draft on ✕ and on Back; « Abandonner » leaves the sheet open', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
@@ -303,28 +325,38 @@ test.describe('citations sheet, editing', () => {
|
||||
await panel(page)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
const field = panel(page).getByLabel(dict['editor.reference.citation'])
|
||||
await field.fill('')
|
||||
await panel(page)
|
||||
.getByRole('button', { name: dict['editor.references.close'] })
|
||||
const form = referenceDialog(page)
|
||||
const field = form.getByLabel(dict['editor.reference.citation'])
|
||||
await field.fill('Brouillon')
|
||||
await form
|
||||
.getByRole('button', { name: dict['common.close'], exact: true })
|
||||
.click()
|
||||
await expect(panel(page)).toBeVisible()
|
||||
await expect(field).toBeFocused()
|
||||
await expect(panel(page).getByRole('alert')).toBeVisible()
|
||||
await page
|
||||
.getByTestId('references-scrim')
|
||||
.click({ position: { x: 4, y: 40 } })
|
||||
await expect(panel(page)).toBeVisible()
|
||||
await link(page).click()
|
||||
await expect(panel(page)).toBeVisible()
|
||||
await expect(page.getByRole('tab', { selected: true })).toHaveText(
|
||||
new RegExp(`^${dict['editor.tab.findings']}`),
|
||||
)
|
||||
// Back: the page stays, the view is pushed again, the refusal shows.
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.keep_typing'] })
|
||||
.click()
|
||||
// Back: the dialog stays, the view is pushed again, the confirmation shows.
|
||||
await page.goBack()
|
||||
await expect(form).toBeVisible()
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await expect(field).toHaveValue('Brouillon')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.keep_typing'] })
|
||||
.click()
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.cancel'] })
|
||||
.click()
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.discard'] })
|
||||
.click()
|
||||
await expect(referenceDialog(page)).toHaveCount(0)
|
||||
await expect(panel(page)).toBeVisible()
|
||||
await expect(findingDialog(page)).toBeVisible()
|
||||
await expect(panel(page).getByRole('alert')).toBeVisible()
|
||||
await expect(undo(page)).toHaveAttribute('aria-disabled', 'true')
|
||||
})
|
||||
|
||||
test('the exiting sheet is inert, and a second close finds nothing to close', async ({
|
||||
|
||||
@@ -0,0 +1,348 @@
|
||||
import { fr } from '@/i18n/fr'
|
||||
import type { Page, TestInfo } from '@playwright/test'
|
||||
import { expect, test } from '../support/browser'
|
||||
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
import {
|
||||
editorActor,
|
||||
expectNoDialog,
|
||||
findingDialog,
|
||||
historyButton,
|
||||
libraryRoot,
|
||||
openEditor,
|
||||
openFinding,
|
||||
openTab,
|
||||
place,
|
||||
referenceDialog,
|
||||
referenceSettled,
|
||||
seedDraft,
|
||||
showCitations,
|
||||
standardShape,
|
||||
} from '../support/editor'
|
||||
|
||||
// R2 UX finish, task 3 (R2F-5, R2F-6): the reference dialog, the reading tiles, the
|
||||
// references filtered by a finding, and the owner's journey through the browser history:
|
||||
// finding A, its sheet, « Tout afficher », the filtered tab, a reference edited, Back,
|
||||
// Forward, « Revenir au constat », then every Back down to the first entry. The top
|
||||
// layer, the focus and the history rules are the browser's, so they are proved here.
|
||||
|
||||
const dict = fr
|
||||
|
||||
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
|
||||
const panel = (page: Page) => page.getByTestId('editor-citations-panel')
|
||||
const chip = (page: Page) =>
|
||||
libraryRoot(page).getByTestId('editor-references-filter')
|
||||
const headers = (page: Page) =>
|
||||
libraryRoot(page).locator('button[aria-controls][id$="-header"]')
|
||||
const undo = (page: Page) => historyButton(page, dict, 'undo')
|
||||
const dialogs = (page: Page) => page.locator('dialog[open]')
|
||||
|
||||
/** « Constat A » cites A and B; « Source libre » is cited by nobody. */
|
||||
function shape(document: Record<string, unknown>) {
|
||||
standardShape(document)
|
||||
const reference = (id: string, citation: string) => ({
|
||||
id,
|
||||
type: 'book',
|
||||
citation,
|
||||
url: null,
|
||||
doi: null,
|
||||
})
|
||||
document.references = [
|
||||
reference('ref-a', 'Référence A'),
|
||||
reference('ref-b', 'Référence B'),
|
||||
reference('ref-c', 'Source libre'),
|
||||
]
|
||||
const zone = (document.finding_zones as { categories: unknown[] }[])[0]
|
||||
const family = zone.categories[0] as {
|
||||
children: { reference_ids: string[] }[]
|
||||
}
|
||||
family.children[0].reference_ids = ['ref-a', 'ref-b']
|
||||
}
|
||||
|
||||
async function open(page: Page) {
|
||||
const actor = await editorActor('fr')
|
||||
const seed = await seedDraft(actor, { shape })
|
||||
await openEditor(page, dict, actor, seed.sheetId)
|
||||
return seed
|
||||
}
|
||||
|
||||
/** The id of the history entry on top: it changes with every push, never with a replace. */
|
||||
const entryId = (page: Page) =>
|
||||
page.evaluate(() => history.state?.usr?.editorEntry?.id as string)
|
||||
|
||||
/** Waits until the entry on top satisfies `view`: the adapter writes a moment after a move. */
|
||||
async function entryHolds(page: Page, test: string) {
|
||||
const view = 'history.state?.usr?.editorEntry?.view'
|
||||
await page.waitForFunction(
|
||||
`(() => { const view = ${view}; return !!(${test}) })()`,
|
||||
)
|
||||
}
|
||||
|
||||
/** Whether the sheet is the dialog on top at the right edge of the viewport. */
|
||||
const sheetOnTop = (page: Page) =>
|
||||
page.evaluate(() => {
|
||||
const top = document.elementFromPoint(window.innerWidth - 40, 100)
|
||||
return !!top?.closest('dialog')?.querySelector('[data-place="citations"]')
|
||||
})
|
||||
|
||||
/** Finding A, its sheet, then « Tout afficher »: the References tab filtered by Constat A. */
|
||||
async function filteredTab(page: Page) {
|
||||
await openFinding(page, dict, 'Constat A')
|
||||
await entryHolds(page, 'view.finding !== null')
|
||||
await showCitations(page)
|
||||
await entryHolds(page, 'view.finding && view.finding.citations')
|
||||
await panel(page)
|
||||
.getByRole('button', { name: dict['editor.references.panel_show_all'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await entryHolds(page, "view.tab === 'references' && !!view.referenceFilter")
|
||||
await expect(chip(page)).toContainText('Constat A')
|
||||
}
|
||||
|
||||
test.describe('the owner journey through the history', () => {
|
||||
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
|
||||
test.beforeEach(async ({ context }) => {
|
||||
await routeToSandbox(context)
|
||||
})
|
||||
test.afterEach(async ({ context }) => {
|
||||
await dropLateReplays(context)
|
||||
})
|
||||
|
||||
test('eight steps: finding, sheet, filter, edit, Back, Forward, Revenir au constat, every Back', async ({
|
||||
page,
|
||||
}, info) => {
|
||||
test.setTimeout(240_000)
|
||||
await open(page)
|
||||
// 1 to 3: the finding dialog, its sheet, « Tout afficher »; 4: the filtered tab.
|
||||
await filteredTab(page)
|
||||
await expect(headers(page)).toHaveCount(2)
|
||||
await expect(
|
||||
libraryRoot(page).getByText('2 références', { exact: true }),
|
||||
).toBeVisible()
|
||||
await expect(page.getByText('Source libre')).toHaveCount(0)
|
||||
const filteredId = await entryId(page)
|
||||
if (!isPhone(info)) {
|
||||
// 5: « Modifier » a tile: the dialog is a layer above the filtered tab, one entry.
|
||||
await headers(page).first().click()
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
const form = referenceDialog(page)
|
||||
await expect(form).toBeVisible()
|
||||
await entryHolds(page, 'view.reference !== null')
|
||||
await form
|
||||
.getByLabel(dict['editor.reference.citation'])
|
||||
.fill('Référence A bis')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.save'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
// One command, one undo; the entry on top is the filtered tab again, no orphan.
|
||||
await expect(undo(page)).toHaveAttribute('aria-disabled', 'false')
|
||||
expect(await entryId(page)).toBe(filteredId)
|
||||
await expect(chip(page)).toBeVisible()
|
||||
}
|
||||
// 6: Back lands on finding A with its sheet open and on top; Forward, on the filter.
|
||||
await page.goBack()
|
||||
await expect(dialogs(page)).toHaveCount(2)
|
||||
expect(await sheetOnTop(page)).toBe(true)
|
||||
await expect(findingDialog(page)).toBeVisible()
|
||||
await page.goForward()
|
||||
await expectNoDialog(page)
|
||||
await expect(chip(page)).toBeVisible()
|
||||
await expect(headers(page)).toHaveCount(2)
|
||||
// 7: « Revenir au constat » pops to the dialog with its sheet (the entry below shows it).
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.references.filter_back'] })
|
||||
.click()
|
||||
await expect(dialogs(page)).toHaveCount(2)
|
||||
expect(await sheetOnTop(page)).toBe(true)
|
||||
await entryHolds(page, 'view.finding && view.finding.citations')
|
||||
// 8: every Back down to the first entry: sheet, dialog, tab, drawing, then it leaves.
|
||||
await page.goBack()
|
||||
await expect(dialogs(page)).toHaveCount(1)
|
||||
await expect(findingDialog(page)).toBeVisible()
|
||||
await page.goBack()
|
||||
await expectNoDialog(page)
|
||||
await expect(place(page, 'findings')).toBeVisible()
|
||||
await page.goBack()
|
||||
await expect(page.getByRole('tab', { selected: true })).toHaveText(
|
||||
new RegExp(`^${dict['editor.tab.annotations']}`),
|
||||
)
|
||||
const here = page.url()
|
||||
await page.goBack()
|
||||
await expect.poll(() => page.url()).not.toBe(here)
|
||||
})
|
||||
|
||||
test('a reload keeps the filtered tab and the chip, never a form; Back then returns to the sheet', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
await open(page)
|
||||
await filteredTab(page)
|
||||
await page.reload()
|
||||
await expect(place(page, 'references')).toBeVisible()
|
||||
await expect(chip(page)).toContainText('Constat A')
|
||||
await expect(headers(page)).toHaveCount(2)
|
||||
await page.goBack()
|
||||
await expect(dialogs(page)).toHaveCount(2)
|
||||
expect(await sheetOnTop(page)).toBe(true)
|
||||
})
|
||||
|
||||
test('the × removes the filter by replace; the search text is not in the history', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
await open(page)
|
||||
await filteredTab(page)
|
||||
const id = await entryId(page)
|
||||
await libraryRoot(page).getByRole('searchbox').fill('Référence')
|
||||
await chip(page)
|
||||
.getByRole('button', {
|
||||
name: dict['editor.references.filter_remove'].replace(
|
||||
'{name}',
|
||||
'Constat A',
|
||||
),
|
||||
})
|
||||
.click()
|
||||
await entryHolds(page, 'view.referenceFilter === null')
|
||||
expect(await entryId(page)).toBe(id)
|
||||
expect(
|
||||
await page.evaluate(() => JSON.stringify(history.state?.usr)),
|
||||
).not.toContain('Référence')
|
||||
// The search is a personal one: removing the filter keeps it (two titles start with it).
|
||||
await expect(headers(page)).toHaveCount(2)
|
||||
await expect(chip(page)).toHaveCount(0)
|
||||
})
|
||||
})
|
||||
|
||||
test.describe('the reference dialog and the history', () => {
|
||||
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
|
||||
test.beforeEach(async ({ context }, info) => {
|
||||
test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; the reading journey above runs at 375
|
||||
await routeToSandbox(context)
|
||||
})
|
||||
test.afterEach(async ({ context }) => {
|
||||
await dropLateReplays(context)
|
||||
})
|
||||
|
||||
/** The References tab with the dialog of the first tile open on its pushed entry. */
|
||||
async function dialogOpen(page: Page) {
|
||||
await open(page)
|
||||
await openTab(page, dict, 'references')
|
||||
await entryHolds(page, "view.tab === 'references'")
|
||||
const base = await entryId(page)
|
||||
await headers(page).first().click()
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
await expect(referenceDialog(page)).toBeVisible()
|
||||
await entryHolds(page, 'view.reference !== null')
|
||||
return base
|
||||
}
|
||||
|
||||
test('a double click on ✕ and on « Enregistrer » pops at most one entry', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
const base = await dialogOpen(page)
|
||||
const form = referenceDialog(page)
|
||||
await form
|
||||
.getByRole('button', { name: dict['common.close'], exact: true })
|
||||
.dblclick()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
expect(await entryId(page)).toBe(base)
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
await entryHolds(page, 'view.reference !== null')
|
||||
await form
|
||||
.getByLabel(dict['editor.reference.citation'])
|
||||
.fill('Référence A bis')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.save'] })
|
||||
.dblclick()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
expect(await entryId(page)).toBe(base)
|
||||
// One command: one « Défaire » restores the citation.
|
||||
await expect(libraryRoot(page).getByText('Référence A bis')).toBeVisible()
|
||||
await undo(page).click()
|
||||
await expect(libraryRoot(page).getByText('Référence A bis')).toHaveCount(0)
|
||||
await expect(undo(page)).toHaveAttribute('aria-disabled', 'true')
|
||||
})
|
||||
|
||||
test('a held Escape closes a pristine dialog and pops at most one entry', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
const base = await dialogOpen(page)
|
||||
await page.keyboard.down('Escape')
|
||||
await page.keyboard.down('Escape')
|
||||
await page.keyboard.down('Escape')
|
||||
await page.keyboard.up('Escape')
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
expect(await entryId(page)).toBe(base)
|
||||
await expect(place(page, 'references')).toBeVisible()
|
||||
})
|
||||
|
||||
test('a real dialog.close() on a dirty dialog keeps it, with its confirmation', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
await dialogOpen(page)
|
||||
const form = referenceDialog(page)
|
||||
await form.getByLabel(dict['editor.reference.doi']).fill('10.1000/x')
|
||||
await page.evaluate(() => {
|
||||
const open = [...document.querySelectorAll('dialog[open]')]
|
||||
;(open.at(-1) as HTMLDialogElement).close()
|
||||
})
|
||||
await expect(form).toBeVisible()
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await expect(form.getByLabel(dict['editor.reference.doi'])).toHaveValue(
|
||||
'10.1000/x',
|
||||
)
|
||||
})
|
||||
|
||||
test('a dirty dialog keeps its draft on Back, one step and a jump across tabs', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(180_000)
|
||||
await open(page)
|
||||
await openTab(page, dict, 'findings')
|
||||
await entryHolds(page, "view.tab === 'findings'")
|
||||
await openTab(page, dict, 'references')
|
||||
await entryHolds(page, "view.tab === 'references'")
|
||||
await headers(page).first().click()
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
await entryHolds(page, 'view.reference !== null')
|
||||
const form = referenceDialog(page)
|
||||
const doi = form.getByLabel(dict['editor.reference.doi'])
|
||||
await doi.fill('10.1000/x')
|
||||
const top = await entryId(page)
|
||||
await page.goBack()
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await expect(doi).toHaveValue('10.1000/x')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.keep_typing'] })
|
||||
.click()
|
||||
// The refused Back pushed the view again: a jump of two entries is refused the same way.
|
||||
await entryHolds(page, 'view.reference !== null')
|
||||
await page.evaluate(() => history.go(-2))
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await expect(doi).toHaveValue('10.1000/x')
|
||||
await expect(form).toBeVisible()
|
||||
expect(await entryId(page)).not.toBe(top)
|
||||
await entryHolds(page, 'view.reference !== null')
|
||||
})
|
||||
})
|
||||
@@ -9,22 +9,27 @@ import {
|
||||
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
import {
|
||||
editorActor,
|
||||
expectNoDialog,
|
||||
historyButton,
|
||||
libraryRoot,
|
||||
openEditor,
|
||||
openTab,
|
||||
place,
|
||||
referenceDialog,
|
||||
referenceSettled,
|
||||
saveDraft,
|
||||
seedDraft,
|
||||
serverDocument,
|
||||
serverRevision,
|
||||
standardShape,
|
||||
startReference,
|
||||
} from '../support/editor'
|
||||
|
||||
// V1-2.6 R2.2: the collapsible reference tiles of the Références tab (boards 23, 24, 27):
|
||||
// closed, open and edit states with axe on each, the keyboard walk through the tile
|
||||
// headers, the leave guard of the edit view, and the read-only twin at 375 px. The spec
|
||||
// seeds its own sheet and never touches another.
|
||||
// V1-2.6 R2.2 and R2F-5: the collapsible reference tiles of the Références tab (boards 23,
|
||||
// 24, 27): closed and open states with axe on each, the reference dialog (« Modifier »,
|
||||
// « Ajouter ») with axe, the keyboard walk through the tile headers, the dialog's draft
|
||||
// and its read-only flip, and the read-only twin at 375 px. The spec seeds its own sheet
|
||||
// and never touches another.
|
||||
|
||||
const dict = fr
|
||||
|
||||
@@ -79,7 +84,7 @@ const REF_DOI = 1
|
||||
const REF_A = 0
|
||||
const REF_FREE = 2
|
||||
|
||||
test.describe('reference tiles, edit mode', () => {
|
||||
test.describe('reference tiles and the reference dialog', () => {
|
||||
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
|
||||
test.beforeEach(async ({ context }, info) => {
|
||||
test.skip(
|
||||
@@ -92,7 +97,7 @@ test.describe('reference tiles, edit mode', () => {
|
||||
await dropLateReplays(context)
|
||||
})
|
||||
|
||||
test('closed, open and edit tiles, accessible in each state', async ({
|
||||
test('closed and open tiles, then the reference dialog, accessible in each state', async ({
|
||||
page,
|
||||
requests,
|
||||
}) => {
|
||||
@@ -139,23 +144,30 @@ test.describe('reference tiles, edit mode', () => {
|
||||
).toBeVisible()
|
||||
await expectAccessible(page, 'the open reference tiles')
|
||||
|
||||
// Edit: the title, the focused citation, « Terminer » only.
|
||||
await cited
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
// « Modifier » opens the dialog: named, over the page, accessible; the tile has no field.
|
||||
const modify = cited.getByRole('button', {
|
||||
name: dict['editor.references.edit'],
|
||||
})
|
||||
await modify.click()
|
||||
const form = referenceDialog(page)
|
||||
await expect(form).toBeVisible()
|
||||
await expect(
|
||||
cited.getByText(dict['editor.references.edit_title']),
|
||||
form.getByRole('heading', { name: dict['editor.references.edit_title'] }),
|
||||
).toBeVisible()
|
||||
await expect(form.locator(':focus')).toHaveCount(1)
|
||||
await expect(
|
||||
cited.getByLabel(dict['editor.reference.citation']),
|
||||
).toBeFocused()
|
||||
await expect(
|
||||
cited.getByRole('button', { name: dict['editor.action.move_up'] }),
|
||||
).toHaveCount(0)
|
||||
await expectAccessible(page, 'a reference tile in edit')
|
||||
await expectAccessible(page, 'the reference dialog')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.cancel'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
await expect(modify).toBeFocused()
|
||||
})
|
||||
|
||||
test('« Terminer » keeps the edit view while a field is refused', async ({
|
||||
test('« Enregistrer » refuses a bad address on its field, then saves one command', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(120_000)
|
||||
@@ -166,29 +178,26 @@ test.describe('reference tiles, edit mode', () => {
|
||||
await tile
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
const url = tile.getByLabel(dict['editor.reference.url'])
|
||||
const form = referenceDialog(page)
|
||||
const url = form.getByLabel(dict['editor.reference.url'])
|
||||
await url.fill('exemple.org')
|
||||
await tile
|
||||
.getByRole('button', {
|
||||
name: dict['editor.references.done'],
|
||||
exact: true,
|
||||
})
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.save'] })
|
||||
.click()
|
||||
await expect(url).toBeFocused()
|
||||
await expect(
|
||||
tile.getByRole('button', {
|
||||
name: dict['editor.references.done'],
|
||||
exact: true,
|
||||
}),
|
||||
).toBeVisible()
|
||||
await expect(url).toHaveAccessibleDescription(
|
||||
dict['editor.reference.url_invalid'],
|
||||
)
|
||||
await expect(historyButton(page, dict, 'undo')).toHaveAttribute(
|
||||
'aria-disabled',
|
||||
'true',
|
||||
)
|
||||
await url.fill('https://exemple.org/page')
|
||||
await tile
|
||||
.getByRole('button', {
|
||||
name: dict['editor.references.done'],
|
||||
exact: true,
|
||||
})
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.save'] })
|
||||
.click()
|
||||
await expect(tile.getByLabel(dict['editor.reference.url'])).toHaveCount(0)
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
await expect(
|
||||
tile.getByRole('link', { name: /exemple\.org/ }),
|
||||
).toHaveAttribute('href', 'https://exemple.org/page')
|
||||
@@ -363,7 +372,7 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
expect(await serverRevision(seed.draftId)).toBe(revision)
|
||||
})
|
||||
|
||||
test('add a reference, save it, then delete an uncited one', async ({
|
||||
test('add a reference: the list stays, a notice offers « Afficher »; then delete an uncited one', async ({
|
||||
page,
|
||||
requests,
|
||||
}) => {
|
||||
@@ -374,28 +383,36 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
const bar = toolbar(page)
|
||||
await bar.sort.selectOption('count')
|
||||
await bar.search.fill('alpha')
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.add'] })
|
||||
.click()
|
||||
await expect(bar.search).toHaveValue('')
|
||||
await expect(bar.sort).toHaveValue('sheet')
|
||||
const citation = libraryRoot(page).getByLabel(
|
||||
dict['editor.reference.citation'],
|
||||
)
|
||||
await expect(citation).toBeFocused()
|
||||
// The focus scrolled the toolbar under the sticky header: axe judges what is covered.
|
||||
await libraryRoot(page).getByRole('searchbox').scrollIntoViewIfNeeded()
|
||||
await expectAccessible(page, 'the draft tile')
|
||||
await libraryRoot(page)
|
||||
.getByLabel(dict['editor.reference.type'])
|
||||
.selectOption('manual')
|
||||
await citation.fill('Nouvelle source')
|
||||
await libraryRoot(page)
|
||||
await startReference(page, dict)
|
||||
// The dialog is a layer over the page: the search and the sort are untouched.
|
||||
await expect(bar.search).toHaveValue('alpha')
|
||||
await expect(bar.sort).toHaveValue('count')
|
||||
const form = referenceDialog(page)
|
||||
await expectAccessible(page, 'the creation dialog')
|
||||
await form.locator('#reference-form-type').selectOption('manual')
|
||||
await form.locator('#reference-form-citation').fill('Nouvelle source')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.reference.add'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
await expect(headers(page)).toHaveCount(1)
|
||||
const notice = libraryRoot(page).getByText(
|
||||
dict['editor.references.added'].replace('{citation}', 'Nouvelle source'),
|
||||
)
|
||||
await expect(notice).toBeVisible()
|
||||
await expect(
|
||||
libraryRoot(page).getByRole('button', {
|
||||
name: dict['editor.references.add'],
|
||||
}),
|
||||
).toBeFocused()
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.added_show'] })
|
||||
.click()
|
||||
await expect(notice).toHaveCount(0)
|
||||
await expect(bar.search).toHaveValue('')
|
||||
await expect(headers(page)).toHaveCount(5)
|
||||
const added = headers(page).last()
|
||||
await expect(added).toContainText('Nouvelle source')
|
||||
const added = headers(page).filter({ hasText: 'Nouvelle source' })
|
||||
await expect(added).toHaveAttribute('aria-expanded', 'true')
|
||||
await expect(added).toBeFocused()
|
||||
await saveDraft(page, dict, seed.revision + 1)
|
||||
@@ -408,6 +425,7 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
])
|
||||
|
||||
// Delete an uncited reference (Étude): the dialog confirms, the tile goes.
|
||||
await bar.sort.selectOption('sheet')
|
||||
await headers(page).nth(3).click()
|
||||
await tileAt(page, 3)
|
||||
.getByRole('button', { name: dict['editor.action.delete'] })
|
||||
@@ -420,7 +438,7 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
await expect(libraryRoot(page).getByText('Étude')).toHaveCount(0)
|
||||
})
|
||||
|
||||
test("« Annuler l'ajout » and Escape drop the draft and write nothing", async ({
|
||||
test('« Annuler » and Escape ask before they drop a typed draft, and write nothing', async ({
|
||||
page,
|
||||
requests,
|
||||
}) => {
|
||||
@@ -434,61 +452,41 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
})
|
||||
const count = await headers(page).count()
|
||||
const states = async () => [
|
||||
await historyButton(page, dict, 'undo').isEnabled(),
|
||||
await historyButton(page, dict, 'redo').isEnabled(),
|
||||
await historyButton(page, dict, 'undo').getAttribute('aria-disabled'),
|
||||
await historyButton(page, dict, 'redo').getAttribute('aria-disabled'),
|
||||
]
|
||||
const before = await states()
|
||||
const draft = root.getByRole('region', {
|
||||
name: dict['editor.reference.new'],
|
||||
})
|
||||
const type = root.getByLabel(dict['editor.reference.type'])
|
||||
await add.click()
|
||||
await type.selectOption('manual')
|
||||
await root.getByLabel(dict['editor.reference.citation']).fill('Brouillon')
|
||||
await root
|
||||
.getByRole('button', { name: dict['editor.references.add_cancel'] })
|
||||
await startReference(page, dict)
|
||||
const form = referenceDialog(page)
|
||||
await form.locator('#reference-form-type').selectOption('manual')
|
||||
await form.locator('#reference-form-citation').fill('Brouillon')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.cancel'] })
|
||||
.click()
|
||||
await expect(draft).toHaveCount(0)
|
||||
await expect(headers(page)).toHaveCount(count)
|
||||
await expect(add).toBeFocused()
|
||||
expect(await states()).toEqual(before)
|
||||
// A typed draft, then Escape on the type select (not a text target): it cancels.
|
||||
await add.click()
|
||||
await root.getByLabel(dict['editor.reference.citation']).fill('Brouillon')
|
||||
await type.focus()
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.keep_typing'] })
|
||||
.click()
|
||||
await expect(form.locator('#reference-form-citation')).toHaveValue(
|
||||
'Brouillon',
|
||||
)
|
||||
await page.keyboard.press('Escape')
|
||||
await expect(draft).toHaveCount(0)
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.discard_ask']),
|
||||
).toBeVisible()
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.discard'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
await expect(headers(page)).toHaveCount(count)
|
||||
await expect(add).toBeFocused()
|
||||
expect(await states()).toEqual(before)
|
||||
})
|
||||
|
||||
test('a tile in edit keeps its place under a sort and under a search', async ({
|
||||
page,
|
||||
requests,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
const { actor } = await open(page, sortShape)
|
||||
requests.forbid(actor.account.email, actor.account.password)
|
||||
await openTab(page, dict, 'references')
|
||||
const bar = toolbar(page)
|
||||
await bar.sort.selectOption('citation')
|
||||
await headers(page).nth(3).click()
|
||||
await tileAt(page, 3)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
await bar.sort.selectOption('count')
|
||||
await expect(
|
||||
tileAt(page, 3).getByLabel(dict['editor.reference.citation']),
|
||||
).toBeVisible()
|
||||
await bar.search.fill('alpha')
|
||||
await expect(headers(page)).toHaveCount(2)
|
||||
await expect(
|
||||
libraryRoot(page).getByLabel(dict['editor.reference.citation']),
|
||||
).toBeVisible()
|
||||
})
|
||||
|
||||
test('a tile edited out of the search stays after « Terminer », with its line, until the next search', async ({
|
||||
test('a tile edited out of the search stays after « Enregistrer », with its line, until the next search', async ({
|
||||
page,
|
||||
requests,
|
||||
}) => {
|
||||
@@ -505,14 +503,12 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
await tile
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
const citation = tile.getByLabel(dict['editor.reference.citation'])
|
||||
await citation.fill('Autre titre')
|
||||
await tile
|
||||
.getByRole('button', {
|
||||
name: dict['editor.references.done'],
|
||||
exact: true,
|
||||
})
|
||||
const form = referenceDialog(page)
|
||||
await form.getByLabel(dict['editor.reference.citation']).fill('Autre titre')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.save'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await expect(
|
||||
tile.getByText(dict['editor.references.outside_search']),
|
||||
).toBeVisible()
|
||||
@@ -523,42 +519,45 @@ test.describe('reference tiles, search, sort and add', () => {
|
||||
await expect(headers(page)).toHaveCount(0)
|
||||
})
|
||||
|
||||
test('a refused draft is never dropped silently by a read-only flip', async ({
|
||||
test('a draft is never dropped by a read-only flip: the dialog keeps it, read-only, with its notice', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(150_000)
|
||||
await open(page)
|
||||
await openTab(page, dict, 'references')
|
||||
const bar = toolbar(page)
|
||||
await headers(page).nth(REF_DOI).click()
|
||||
const tile = libraryRoot(page)
|
||||
.locator('button[id$="-ref-doi-header"]')
|
||||
.locator('xpath=ancestor::li[1]')
|
||||
await tile
|
||||
await tileAt(page, REF_DOI)
|
||||
.getByRole('button', { name: dict['editor.references.edit'] })
|
||||
.click()
|
||||
await bar.search.fill('libre')
|
||||
const url = tile.getByLabel(dict['editor.reference.url'])
|
||||
const form = referenceDialog(page)
|
||||
const url = form.getByLabel(dict['editor.reference.url'])
|
||||
await url.fill('exemple.org')
|
||||
const note = dict['editor.references.draft_dropped'].replace(
|
||||
'{field}',
|
||||
dict['editor.reference.url'],
|
||||
)
|
||||
const size = page.viewportSize() ?? { width: 1280, height: 900 }
|
||||
await page.setViewportSize({ width: 800, height: size.height })
|
||||
await expect(tile.getByText(note)).toBeVisible()
|
||||
await expect(page.locator('p.sr-only[aria-live="polite"]')).toHaveText(note)
|
||||
await expect(url).toHaveCount(0)
|
||||
await expect(form).toBeVisible()
|
||||
await expect(url).toHaveAttribute('readonly', '')
|
||||
await expect(url).toHaveValue('exemple.org')
|
||||
await expect(
|
||||
form.getByText(dict['editor.findings.flip_narrow']),
|
||||
).toBeVisible()
|
||||
await expect(
|
||||
form.getByRole('button', { name: dict['editor.findings.save'] }),
|
||||
).toBeDisabled()
|
||||
await page.setViewportSize(size)
|
||||
await expect(tile.getByText(note)).toBeVisible()
|
||||
await expect(url).toHaveValue(`https://doi.org/${DOI}`)
|
||||
await tile
|
||||
.getByRole('button', {
|
||||
name: dict['editor.references.done'],
|
||||
exact: true,
|
||||
})
|
||||
await expect(url).not.toHaveAttribute('readonly', '')
|
||||
await expect(url).toHaveValue('exemple.org')
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.cancel'] })
|
||||
.click()
|
||||
await expect(tile.getByText(note)).toHaveCount(0)
|
||||
await form
|
||||
.getByRole('button', { name: dict['editor.findings.discard'] })
|
||||
.click()
|
||||
await expectNoDialog(page)
|
||||
await expect(
|
||||
tileAt(page, REF_DOI)
|
||||
.getByRole('link', { name: new RegExp(DOI) })
|
||||
.first(),
|
||||
).toBeVisible()
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
@@ -8,9 +8,9 @@ import {
|
||||
closeFinding,
|
||||
copyKeyOf,
|
||||
editorActor,
|
||||
expectNoDialog,
|
||||
geometryField,
|
||||
historyButton,
|
||||
libraryRoot,
|
||||
openEditor,
|
||||
openCitations,
|
||||
openTab,
|
||||
@@ -23,6 +23,7 @@ import {
|
||||
selectTab,
|
||||
shapeWith,
|
||||
standardShape,
|
||||
startReference,
|
||||
storedCopy,
|
||||
UNSAVED_LINE,
|
||||
} from '../support/editor'
|
||||
@@ -217,21 +218,37 @@ test.describe('editor shell, width crossing (H)', () => {
|
||||
)
|
||||
})
|
||||
|
||||
test('the references form keeps its typed text, in the Références tab', async ({
|
||||
test('the reference dialog stays while narrow: draft, focus and a notice kept (R2F-5)', async ({
|
||||
page,
|
||||
}) => {
|
||||
await open(page)
|
||||
await openTab(page, dict, 'references')
|
||||
await startReference(page, dict)
|
||||
const field = page.locator('#reference-form-citation')
|
||||
await field.fill('Saisie')
|
||||
await expect(field).toBeFocused()
|
||||
await page.setViewportSize(NARROW)
|
||||
await expect(field).toBeVisible()
|
||||
await expect(field).toHaveAttribute('readonly', '')
|
||||
await expect(field).toHaveValue('Saisie')
|
||||
await expect(field).toBeFocused()
|
||||
await expect(
|
||||
page.getByText(dict['editor.findings.flip_narrow']),
|
||||
).toBeVisible()
|
||||
await expect(
|
||||
page.getByRole('button', { name: dict['editor.reference.add'] }),
|
||||
).toBeDisabled()
|
||||
await page.setViewportSize(WIDE)
|
||||
await expect(field).not.toHaveAttribute('readonly', '')
|
||||
await expect(field).toHaveValue('Saisie')
|
||||
await expect(field).toBeFocused()
|
||||
await expect(saveLine(page)).not.toHaveText(UNSAVED_LINE)
|
||||
await page.keyboard.press('Escape')
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.references.add'] })
|
||||
.locator('dialog[open]')
|
||||
.getByRole('button', { name: dict['editor.findings.discard'] })
|
||||
.click()
|
||||
await keepsTypedValue(
|
||||
page,
|
||||
page.locator('#tab-reference-new-citation'),
|
||||
dict['editor.reference.add'],
|
||||
'references',
|
||||
)
|
||||
await expect(libraryRoot(page).getByRole('searchbox')).toBeVisible()
|
||||
await expectNoDialog(page)
|
||||
})
|
||||
|
||||
test('the annotation edit body keeps its tool and its pending creation', async ({
|
||||
|
||||
@@ -3,6 +3,7 @@ import type { Locator, Page, TestInfo } from '@playwright/test'
|
||||
import { expect, test } from '../support/browser'
|
||||
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
import {
|
||||
addReference,
|
||||
backToDrawing,
|
||||
copyKeyOf,
|
||||
storedCopy,
|
||||
@@ -94,20 +95,18 @@ test.describe('editor shell, kept places (B2a)', () => {
|
||||
expect(await layerTransform(page)).toBe(zoomed)
|
||||
})
|
||||
|
||||
test('the Références tab keeps its form text and no id repeats, panel open included', async ({
|
||||
test('the Références tab keeps its search and no id repeats, panel open included', async ({
|
||||
page,
|
||||
}) => {
|
||||
await open(page)
|
||||
await openTab(page, dict, 'references')
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.references.add'] })
|
||||
.click()
|
||||
await page.locator('#tab-reference-new-citation').fill('Smith 1999')
|
||||
const search = page.getByRole('searchbox', {
|
||||
name: dict['editor.references.search'],
|
||||
})
|
||||
await search.fill('Smith 1999')
|
||||
await openTab(page, dict, 'general')
|
||||
await openTab(page, dict, 'references')
|
||||
await expect(page.locator('#tab-reference-new-citation')).toHaveValue(
|
||||
'Smith 1999',
|
||||
)
|
||||
await expect(search).toHaveValue('Smith 1999')
|
||||
for (const tab of ['general', 'findings', 'verification']) {
|
||||
await selectTab(page, dict, tab)
|
||||
}
|
||||
@@ -133,14 +132,7 @@ test.describe('editor shell, kept places (B2a)', () => {
|
||||
await open(page)
|
||||
// An edit first, so « Enregistrer » is enabled: a reference added in its tab.
|
||||
await openTab(page, dict, 'references')
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.references.add'] })
|
||||
.click()
|
||||
await page.locator('#tab-reference-new-type').selectOption('book')
|
||||
await page.locator('#tab-reference-new-citation').fill('Smith 1999')
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.reference.add'] })
|
||||
.click()
|
||||
await addReference(page, dict, 'Smith 1999')
|
||||
await openCitations(page, dict, 'Constat A')
|
||||
const targets = [
|
||||
page.getByRole('button', { name: dict['common.save'], exact: true }),
|
||||
|
||||
@@ -3,6 +3,7 @@ import type { Locator, Page, TestInfo } from '@playwright/test'
|
||||
import { expect, expectAccessible, test } from '../support/browser'
|
||||
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
import {
|
||||
addReference,
|
||||
bareShape,
|
||||
closeFinding,
|
||||
editorActor,
|
||||
@@ -85,17 +86,10 @@ test.describe('editor structures (A4)', () => {
|
||||
// « Référence A » stays first: it is cited by « Constat A »).
|
||||
await openTab(page, dict, 'references')
|
||||
for (const citation of ['Première référence', 'Seconde référence']) {
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.references.add'] })
|
||||
.click()
|
||||
await page.locator('#tab-reference-new-type').selectOption('book')
|
||||
await page.locator('#tab-reference-new-citation').fill(citation)
|
||||
await page
|
||||
.getByRole('button', { name: dict['editor.reference.add'] })
|
||||
.click()
|
||||
await addReference(page, dict, citation)
|
||||
await expect(
|
||||
page.getByRole('button', { name: new RegExp(`^${citation}`) }),
|
||||
).toBeFocused()
|
||||
).toBeVisible()
|
||||
}
|
||||
const tiles = page.locator('[id^="tab-reference-"][id$="-header"]')
|
||||
const tileOf = (citation: string) =>
|
||||
@@ -112,17 +106,13 @@ test.describe('editor structures (A4)', () => {
|
||||
await expect(tiles).toHaveCount(1)
|
||||
await search.fill('')
|
||||
await expect(tiles).toHaveCount(3)
|
||||
// An added tile stays open (P24): no click, a click would close it.
|
||||
await expect(
|
||||
tiles.filter({ hasText: 'Seconde référence' }),
|
||||
).toHaveAttribute('aria-expanded', 'true')
|
||||
// An added tile is closed (the list does not move, R2F-5): open it, then move it.
|
||||
await tiles.filter({ hasText: 'Seconde référence' }).click()
|
||||
await tileOf('Seconde référence')
|
||||
.getByRole('button', { name: dict['editor.action.move_up'] })
|
||||
.click()
|
||||
await expect(tiles.nth(1)).toContainText('Seconde référence')
|
||||
await expect(
|
||||
tiles.filter({ hasText: 'Première référence' }),
|
||||
).toHaveAttribute('aria-expanded', 'true')
|
||||
await tiles.filter({ hasText: 'Première référence' }).click()
|
||||
await tileOf('Première référence')
|
||||
.getByRole('button', { name: dict['editor.action.delete'] })
|
||||
.click()
|
||||
|
||||
@@ -427,11 +427,58 @@ export async function openTab(page: Page, dict: Dict, tab: string) {
|
||||
).toBeVisible()
|
||||
}
|
||||
|
||||
/** The open finding dialog: the layer dialog that is not the citations sheet. */
|
||||
/** The open finding dialog: the layer dialog that is neither the sheet nor the reference form. */
|
||||
export const findingDialog = (page: Page): Locator =>
|
||||
page.locator('dialog[open][data-layer]').filter({
|
||||
hasNot: page.locator('[data-place="citations"], #reference-form-citation'),
|
||||
})
|
||||
|
||||
/** The open reference dialog (R2F-5): the layer dialog that holds the reference form. */
|
||||
export const referenceDialog = (page: Page): Locator =>
|
||||
page
|
||||
.locator('dialog[open][data-layer]')
|
||||
.filter({ hasNot: page.locator('[data-place="citations"]') })
|
||||
.filter({ has: page.locator('#reference-form-citation') })
|
||||
|
||||
/**
|
||||
* Waits for the history to settle on a view without the reference layer (or, with
|
||||
* `keepDialog`, with one): a close pops its entry from an effect, and a move made before
|
||||
* the pop lands would be undone by it (a user cannot be that quick, a script can).
|
||||
*/
|
||||
export async function referenceSettled(page: Page, keepDialog = false) {
|
||||
await page.waitForFunction((stays) => {
|
||||
const view = history.state?.usr?.editorEntry?.view
|
||||
if (!view) return true
|
||||
return stays ? view.reference !== null : view.reference === null
|
||||
}, keepDialog)
|
||||
}
|
||||
|
||||
/** Opens « Ajouter une référence » (the References tab is shown): the form is ready. */
|
||||
export async function startReference(page: Page, dict: Dict) {
|
||||
await libraryRoot(page)
|
||||
.getByRole('button', { name: dict['editor.references.add'] })
|
||||
.click()
|
||||
await expect(referenceDialog(page)).toBeVisible()
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a reference through the dialog and waits for every layer to be gone. The list
|
||||
* does not move and the focus goes back to « Ajouter » (R2F-5): nothing is focused on the
|
||||
* new tile.
|
||||
*/
|
||||
export async function addReference(
|
||||
page: Page,
|
||||
dict: Dict,
|
||||
citation: string,
|
||||
type = 'book',
|
||||
) {
|
||||
await startReference(page, dict)
|
||||
const form = referenceDialog(page)
|
||||
await form.locator('#reference-form-type').selectOption(type)
|
||||
await form.locator('#reference-form-citation').fill(citation)
|
||||
await form.getByRole('button', { name: dict['editor.reference.add'] }).click()
|
||||
await expectNoDialog(page)
|
||||
await referenceSettled(page)
|
||||
}
|
||||
|
||||
/** Waits until no modal dialog is open: nothing is typed or pressed before (LRN-111/116). */
|
||||
export const expectNoDialog = (page: Page) =>
|
||||
|
||||
@@ -28,10 +28,10 @@ export default function FindingsHost({
|
||||
<CitationsSheet
|
||||
citedBy={citationsOfView(nav.state)}
|
||||
readOnly={readOnly}
|
||||
guards={nav.guards}
|
||||
onClose={nav.closeCitations}
|
||||
onShowAll={nav.showAllReferences}
|
||||
onShowAll={() => undefined}
|
||||
navigate={nav.navigate}
|
||||
onEdit={nav.references.open}
|
||||
returnFocus={nav.citationsTrigger}
|
||||
/>
|
||||
</ReadOnlyContext>
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
import { vi } from 'vitest'
|
||||
import ReferenceDialog from '@/components/editor/references/ReferenceDialog'
|
||||
import ReferencesTab from '@/components/editor/tabs/ReferencesTab'
|
||||
import { ReadOnlyContext } from '@/editor/editingContext'
|
||||
import { referenceLayerOf } from '@/editor/findingLayer'
|
||||
import { AnnounceContext } from '@/editor/focusRequest'
|
||||
import { defaultView, type EditorView } from '@/editor/navigation'
|
||||
import type { EditorPlaceProps } from '@/editor/tabs'
|
||||
import {
|
||||
useEditorNavigation,
|
||||
type EditorNavigation,
|
||||
} from '@/editor/useEditorNavigation'
|
||||
|
||||
interface Props extends Partial<EditorPlaceProps> {
|
||||
/** The view the editor starts on (a filter, a dialog); the References tab by default. */
|
||||
view?: EditorView
|
||||
/** Reads the navigation each render, for a test that drives or inspects it. */
|
||||
onNav?: (nav: EditorNavigation) => void
|
||||
/** Renders the polite live region (the workspace's), for a test that reads announcements. */
|
||||
live?: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* The References tab with the navigation that drives its dialog and its filter (what the
|
||||
* workspace gives it), without the rest of the editor.
|
||||
*/
|
||||
export default function ReferencesHost({
|
||||
readOnly = false,
|
||||
view,
|
||||
onNav,
|
||||
live = false,
|
||||
...extra
|
||||
}: Props) {
|
||||
const nav = useEditorNavigation(
|
||||
'references',
|
||||
view ?? defaultView('references'),
|
||||
)
|
||||
onNav?.(nav)
|
||||
const references = referenceLayerOf(nav)
|
||||
return (
|
||||
<ReadOnlyContext value={readOnly}>
|
||||
<AnnounceContext value={nav.announce}>
|
||||
<ReferencesTab
|
||||
readOnly={readOnly}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
{...extra}
|
||||
references={references}
|
||||
/>
|
||||
<ReferenceDialog layer={references} readOnly={readOnly} />
|
||||
</AnnounceContext>
|
||||
{live && <p aria-live="polite">{nav.live}</p>}
|
||||
</ReadOnlyContext>
|
||||
)
|
||||
}
|
||||
@@ -13,13 +13,13 @@ import type {
|
||||
AnatomicalSheetDocument,
|
||||
ElementKey,
|
||||
} from '@faunosteo/core-wasm/types'
|
||||
import { findingLayerOf } from '@/editor/findingLayer'
|
||||
import { findingLayerOf, referenceLayerOf } from '@/editor/findingLayer'
|
||||
import { testLayer } from '../helpers/findingsHost'
|
||||
import ReferencesHost from '../helpers/referencesHost'
|
||||
import FindingsTab from '@/components/editor/tabs/FindingsTab'
|
||||
import RegionsSection from '@/components/editor/annotations/sections/RegionsSection'
|
||||
import EditorTabBody from '@/components/editor/EditorTabBody'
|
||||
import EditorTabs from '@/components/editor/EditorTabs'
|
||||
import ReferencesTab from '@/components/editor/tabs/ReferencesTab'
|
||||
import AnnotationsTab from '@/components/editor/tabs/AnnotationsTab'
|
||||
import {
|
||||
FocusConsumedContext,
|
||||
@@ -164,7 +164,7 @@ describe('focus requests', () => {
|
||||
})
|
||||
await openReady({ text })
|
||||
render(
|
||||
<ReferencesTab
|
||||
<ReferencesHost
|
||||
{...base}
|
||||
focus={request({ kind: 'reference', id: 'ref-a' })}
|
||||
/>,
|
||||
@@ -200,9 +200,9 @@ describe('focus requests', () => {
|
||||
})
|
||||
await openReady({ text })
|
||||
const focus = request({ kind: 'reference', id: 'ref-a' })
|
||||
const view = render(<ReferencesTab {...base} focus={focus} />)
|
||||
const view = render(<ReferencesHost {...base} focus={focus} />)
|
||||
;(document.activeElement as HTMLElement).blur()
|
||||
view.rerender(<ReferencesTab {...base} focus={focus} />)
|
||||
view.rerender(<ReferencesHost {...base} focus={focus} />)
|
||||
expect(document.activeElement?.getAttribute('data-focus-key')).toBeNull()
|
||||
})
|
||||
|
||||
@@ -271,6 +271,7 @@ function Probe({ go, tier }: { go: EditorTarget; tier: 'wide' | 'small' }) {
|
||||
{...base}
|
||||
navigate={nav.navigate}
|
||||
layer={findingLayerOf(nav)}
|
||||
references={referenceLayerOf(nav)}
|
||||
focus={state.focus}
|
||||
annotations={{
|
||||
section: state.section,
|
||||
@@ -288,7 +289,17 @@ function ShowAllProbe() {
|
||||
return (
|
||||
<>
|
||||
<EditorTabs active={nav.state.tab} tier="wide" onSelect={nav.selectTab} />
|
||||
<button onClick={nav.showAllReferences}>show all</button>
|
||||
<button
|
||||
onClick={() =>
|
||||
nav.showAllReferences({
|
||||
kind: 'finding',
|
||||
zone_id: 'zone-a',
|
||||
path: ['fcat-a', 'fnode-a'],
|
||||
})
|
||||
}
|
||||
>
|
||||
show all
|
||||
</button>
|
||||
</>
|
||||
)
|
||||
}
|
||||
@@ -419,7 +430,7 @@ function Harness() {
|
||||
switch
|
||||
</button>
|
||||
{shown === 'references' ? (
|
||||
<ReferencesTab {...base} focus={focus} />
|
||||
<ReferencesHost {...base} focus={focus} />
|
||||
) : (
|
||||
<RegionsSection {...base} focus={focus} />
|
||||
)}
|
||||
|
||||
@@ -86,6 +86,43 @@ describe('sanitizeView', () => {
|
||||
expect(sanitizeView(odd)?.finding).toBeNull()
|
||||
})
|
||||
|
||||
it('the reference dialog is a form: over References or the sheet, never at a reload', () => {
|
||||
const edit = { edit: 'ref-a' }
|
||||
const tab = { ...view('references'), reference: edit }
|
||||
expect(sanitizeView(tab)?.reference).toEqual(edit)
|
||||
expect(sanitizeView(tab, false)?.reference).toBeNull()
|
||||
const sheet = {
|
||||
...view('findings'),
|
||||
finding: { key: node, citations: true },
|
||||
reference: edit,
|
||||
}
|
||||
expect(sanitizeView(sheet)?.reference).toEqual(edit)
|
||||
const noSheet = { ...sheet, finding: { key: node, citations: false } }
|
||||
expect(sanitizeView(noSheet)?.reference).toBeNull()
|
||||
const creation = { ...view('references'), reference: { create: true } }
|
||||
expect(sanitizeView(creation)?.reference).toEqual({ create: true })
|
||||
const elsewhere = { ...view('general'), reference: { create: true } }
|
||||
expect(sanitizeView(elsewhere)?.reference).toBeNull()
|
||||
expect(
|
||||
sanitizeView({ ...tab, reference: { edit: '' } })?.reference,
|
||||
).toBeNull()
|
||||
})
|
||||
|
||||
it('the finding filter names a finding node and lives on the References tab only', () => {
|
||||
const filtered = view('references', { referenceFilter: node })
|
||||
expect(sanitizeView(filtered)?.referenceFilter).toEqual(node)
|
||||
expect(sanitizeView(filtered, false)?.referenceFilter).toEqual(node)
|
||||
expect(
|
||||
sanitizeView({ ...view('general'), referenceFilter: node })
|
||||
?.referenceFilter,
|
||||
).toBeNull()
|
||||
const zone = { kind: 'zone', id: 'z' }
|
||||
expect(
|
||||
sanitizeView({ ...view('references'), referenceFilter: zone })
|
||||
?.referenceFilter,
|
||||
).toBeNull()
|
||||
})
|
||||
|
||||
it('drops what is no view: an unknown tab, a non-object', () => {
|
||||
expect(sanitizeView({ tab: 'nowhere', section: 'views' })).toBeNull()
|
||||
expect(sanitizeView('general')).toBeNull()
|
||||
@@ -211,6 +248,46 @@ describe('planWrite', () => {
|
||||
})
|
||||
})
|
||||
|
||||
describe('planWrite and the reference layers', () => {
|
||||
const sheet = view('findings', { finding: { key: node, citations: true } })
|
||||
const dialog = { ...sheet, reference: { edit: 'ref-a' } }
|
||||
const top = (v: EditorView, below: EditorView | null) =>
|
||||
entry({ view: v, below })
|
||||
|
||||
it('the reference dialog is a layer: added pushes, removed goes back to the view below', () => {
|
||||
expect(planWrite(top(sheet, null), dialog, false)).toBe('push')
|
||||
expect(planWrite(top(dialog, sheet), sheet, false)).toBe('back')
|
||||
expect(planWrite(top(dialog, view('general')), sheet, false)).toBe(
|
||||
'replace',
|
||||
)
|
||||
expect(layerCount(dialog)).toBe(3)
|
||||
})
|
||||
|
||||
it('a creation turned into its element is a replace; the filter removal is a replace hint', () => {
|
||||
const creating = view('references', { reference: { create: true } })
|
||||
const editing = view('references', { reference: { edit: 'ref-n' } })
|
||||
expect(planWrite(top(creating, null), editing, true)).toBe('replace')
|
||||
const filtered = view('references', { referenceFilter: node })
|
||||
expect(planWrite(top(filtered, sheet), view('references'), true)).toBe(
|
||||
'replace',
|
||||
)
|
||||
})
|
||||
|
||||
it('« Revenir au constat » goes back when the entry below shows that finding, else pushes', () => {
|
||||
const filtered = view('references', { referenceFilter: node })
|
||||
const dialogOnly = view('findings', {
|
||||
finding: { key: node, citations: false },
|
||||
})
|
||||
expect(planWrite(top(filtered, sheet), dialogOnly, false, node)).toBe(
|
||||
'back',
|
||||
)
|
||||
expect(
|
||||
planWrite(top(filtered, view('general')), dialogOnly, false, node),
|
||||
).toBe('push')
|
||||
expect(planWrite(top(filtered, sheet), dialogOnly, false)).toBe('push')
|
||||
})
|
||||
})
|
||||
|
||||
describe('createWriteBudget', () => {
|
||||
it('lets the limit through per window, then refuses until the window slides', () => {
|
||||
const take = createWriteBudget(3, 1000)
|
||||
|
||||
@@ -131,19 +131,23 @@ describe('the guard stack', () => {
|
||||
const { result } = renderHook(() => useEditorNavigation('general'))
|
||||
const { guards } = result.current
|
||||
const order: string[] = []
|
||||
guards.register('citations', () => {
|
||||
order.push('citations')
|
||||
guards.register('reference', () => {
|
||||
order.push('reference')
|
||||
return { allowed: true, note: 'a' }
|
||||
})
|
||||
guards.register('finding', () => {
|
||||
order.push('finding')
|
||||
return { allowed: false, note: 'b' }
|
||||
})
|
||||
expect(guards.ask('reference', false)).toEqual({ allowed: true })
|
||||
expect(guards.ask('reference', false)).toEqual({
|
||||
allowed: true,
|
||||
note: 'a',
|
||||
})
|
||||
expect(guards.ask('finding', true).allowed).toBe(false)
|
||||
order.length = 0
|
||||
expect(guards.askAll(false)).toEqual({ allowed: false, note: 'b. a' })
|
||||
expect(order).toEqual(['finding', 'citations'])
|
||||
// The reference dialog is the top layer: it is asked first.
|
||||
expect(guards.askAll(false)).toEqual({ allowed: false, note: 'a. b' })
|
||||
expect(order).toEqual(['reference', 'finding'])
|
||||
guards.register('finding', null)
|
||||
expect(guards.askAll(false).allowed).toBe(true)
|
||||
})
|
||||
|
||||
@@ -10,7 +10,6 @@ import {
|
||||
within,
|
||||
} from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import type { AnatomicalSheetDocument } from '@faunosteo/core-wasm/types'
|
||||
import EditorTabBody from '@/components/editor/EditorTabBody'
|
||||
import KeptPlace from '@/components/editor/KeptPlace'
|
||||
import { useSheetDocument } from '@/editor/sheetDocument'
|
||||
@@ -36,7 +35,6 @@ import {
|
||||
versionAnswer,
|
||||
} from '../helpers/editorHarness'
|
||||
import { testLayer } from '../helpers/findingsHost'
|
||||
import { openFinding } from '../helpers/findingDialog'
|
||||
import { mountDraft, setWidth } from '../helpers/editorRoute'
|
||||
|
||||
vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
|
||||
@@ -112,26 +110,6 @@ function findingsText(from = baseText(), nodeRefs?: string[]): string {
|
||||
})
|
||||
}
|
||||
|
||||
function referenceText(): string {
|
||||
return insert(baseText(), {
|
||||
kind: 'reference',
|
||||
value: {
|
||||
id: 'ref-1',
|
||||
type: 'journal',
|
||||
citation: 'Doe 2020',
|
||||
url: null,
|
||||
doi: null,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
/** Constats, the node selected, its « 1 référence » trigger pressed. */
|
||||
async function openCitations(user: Awaited<ReturnType<typeof mount>>) {
|
||||
await user.click(tab('Constats'))
|
||||
await openFinding(user, /Node A/)
|
||||
await user.click(screen.getByRole('button', { name: '1 référence' }))
|
||||
}
|
||||
|
||||
async function mount(text = baseText()) {
|
||||
serverHas(text, 3)
|
||||
const user = userEvent.setup()
|
||||
@@ -199,22 +177,17 @@ describe('text typed in a place that is left', () => {
|
||||
expect(store.getState().unsaved).toBe(false)
|
||||
})
|
||||
|
||||
it('the reference add form survives leaving and returning to the Références tab', async () => {
|
||||
it('the references search survives leaving and returning to the Références tab', async () => {
|
||||
const user = await mount()
|
||||
await user.click(tab('Références'))
|
||||
await user.click(
|
||||
inPlace('references').getByRole('button', {
|
||||
name: 'Ajouter une référence',
|
||||
}),
|
||||
)
|
||||
const field = inPlace('references').getByLabelText('Citation', {
|
||||
selector: '#tab-reference-new-citation',
|
||||
const box = inPlace('references').getByRole('searchbox', {
|
||||
name: 'Rechercher une référence',
|
||||
})
|
||||
await user.type(field, 'Smith 1999')
|
||||
await user.type(box, 'Smith 1999')
|
||||
await user.click(tab('Annotations'))
|
||||
expect(place('references')).not.toBeVisible()
|
||||
await user.click(tab('Références'))
|
||||
expect(field).toHaveValue('Smith 1999')
|
||||
expect(box).toHaveValue('Smith 1999')
|
||||
expect(store.getState().unsaved).toBe(false)
|
||||
})
|
||||
})
|
||||
@@ -328,67 +301,6 @@ describe('a field still focused while a place is left', () => {
|
||||
act(() => void store.getState().undoStep())
|
||||
expect(store.getState().documentText).toBe(before)
|
||||
})
|
||||
|
||||
it('a tab click without a focus move commits the Références text, as one undo entry', async () => {
|
||||
const user = await mount(referenceText())
|
||||
const before = store.getState().documentText
|
||||
await user.click(tab('Références'))
|
||||
await user.click(inPlace('references').getByRole('button', { name: /Doe/ }))
|
||||
await user.click(
|
||||
inPlace('references').getByRole('button', { name: 'Modifier' }),
|
||||
)
|
||||
const field = inPlace('references').getByLabelText('Citation', {
|
||||
selector: '#tab-reference-0-ref-1-citation',
|
||||
})
|
||||
await user.click(field)
|
||||
fireEvent.change(field, { target: { value: 'Doe 2023' } })
|
||||
fireEvent.click(tab(/Vérification/))
|
||||
expect(
|
||||
JSON.parse(store.getState().documentText).references[0].citation,
|
||||
).toBe('Doe 2023')
|
||||
expect(store.getState().unsaved).toBe(true)
|
||||
expect(place('references')).not.toBeVisible()
|
||||
act(() => void store.getState().undoStep())
|
||||
expect(store.getState().documentText).toBe(before)
|
||||
})
|
||||
|
||||
/** The panel's first tile opened in edit, its citation field typed in (not blurred). */
|
||||
async function typeInPanelTile(user: Awaited<ReturnType<typeof mount>>) {
|
||||
await openCitations(user)
|
||||
const panel = inPlace('citations')
|
||||
await user.click(panel.getByRole('button', { name: /Doe/ }))
|
||||
await user.click(panel.getByRole('button', { name: 'Modifier' }))
|
||||
const field = panel.getByLabelText('Citation', {
|
||||
selector: '#panel-reference-0-ref-1-citation',
|
||||
})
|
||||
await user.click(field)
|
||||
fireEvent.change(field, { target: { value: 'Doe 2021' } })
|
||||
return field
|
||||
}
|
||||
|
||||
const savedCitation = () =>
|
||||
(JSON.parse(store.getState().documentText) as AnatomicalSheetDocument)
|
||||
.references[0].citation
|
||||
|
||||
it('Escape in a field of a panel tile neither closes the panel nor commits the text (A5)', async () => {
|
||||
const user = await mount(findingsText(referenceText(), ['ref-1']))
|
||||
const before = store.getState().documentText
|
||||
await typeInPanelTile(user)
|
||||
await user.keyboard('{Escape}')
|
||||
expect(screen.getByTestId('editor-citations-panel')).toBeInTheDocument()
|
||||
expect(store.getState().documentText).toBe(before)
|
||||
})
|
||||
|
||||
it('the scrim (no focus move) commits the typed text, then closes the panel after its exit', async () => {
|
||||
const user = await mount(findingsText(referenceText(), ['ref-1']))
|
||||
await typeInPanelTile(user)
|
||||
fireEvent.click(screen.getByTestId('references-scrim'))
|
||||
expect(savedCitation()).toBe('Doe 2021')
|
||||
await waitFor(() =>
|
||||
expect(screen.queryByTestId('editor-citations-panel')).toBeNull(),
|
||||
)
|
||||
expect(store.getState().unsaved).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('ids and parses', () => {
|
||||
|
||||
@@ -147,16 +147,69 @@ describe('navigationReducer', () => {
|
||||
const state = run(
|
||||
initialNavigation('findings'),
|
||||
{ type: 'open_citations', citedBy: node },
|
||||
{ type: 'show_all_references' },
|
||||
{ type: 'show_all_references', filter: node },
|
||||
)
|
||||
expect(state).toMatchObject({
|
||||
tab: 'references',
|
||||
finding: null,
|
||||
referenceFilter: node,
|
||||
libraryReset: 1,
|
||||
focus: undefined,
|
||||
})
|
||||
expect(state.visitedTabs).toEqual(['findings', 'references'])
|
||||
expect(run(state, { type: 'show_all_references' }).libraryReset).toBe(2)
|
||||
const again = run(state, { type: 'show_all_references', filter: node })
|
||||
expect(again.libraryReset).toBe(2)
|
||||
})
|
||||
|
||||
it('the reference dialog is a layer above the place and the sheet', () => {
|
||||
const open = run(
|
||||
initialNavigation('findings'),
|
||||
{ type: 'open_citations', citedBy: node },
|
||||
{ type: 'open_reference', id: 'ref-a' },
|
||||
)
|
||||
expect(open).toMatchObject({
|
||||
tab: 'findings',
|
||||
finding: { key: node, citations: true },
|
||||
reference: { edit: 'ref-a' },
|
||||
})
|
||||
expect(run(open, { type: 'close_reference' }).reference).toBeNull()
|
||||
const created = run(initialNavigation('general'), {
|
||||
type: 'create_reference',
|
||||
})
|
||||
expect(created).toMatchObject({
|
||||
tab: 'references',
|
||||
reference: { create: true },
|
||||
})
|
||||
})
|
||||
|
||||
it('the filter belongs to the References tab: any move to another tab drops it', () => {
|
||||
const filtered = run(initialNavigation('findings'), {
|
||||
type: 'show_all_references',
|
||||
filter: node,
|
||||
})
|
||||
expect(
|
||||
run(filtered, { type: 'select_tab', tab: 'references' }),
|
||||
).toMatchObject({
|
||||
referenceFilter: node,
|
||||
})
|
||||
expect(run(filtered, { type: 'select_tab', tab: 'general' })).toMatchObject(
|
||||
{
|
||||
referenceFilter: null,
|
||||
},
|
||||
)
|
||||
expect(run(filtered, { type: 'open_finding', key: node })).toMatchObject({
|
||||
tab: 'findings',
|
||||
referenceFilter: null,
|
||||
finding: { key: node, citations: false },
|
||||
})
|
||||
const toReference = run(filtered, {
|
||||
type: 'go_to',
|
||||
target: targetOfKey({ kind: 'reference', id: 'x' }),
|
||||
})
|
||||
expect(toReference.referenceFilter).toBeNull()
|
||||
expect(
|
||||
run(filtered, { type: 'clear_reference_filter' }).referenceFilter,
|
||||
).toBeNull()
|
||||
})
|
||||
|
||||
it('a plain go_to a reference leaves the library reset alone', () => {
|
||||
|
||||
@@ -143,18 +143,6 @@ describe('typed values come back after a 1 024 px crossing', () => {
|
||||
)
|
||||
})
|
||||
|
||||
it('the reference creation form, in the Références tab', async () => {
|
||||
const user = await mount()
|
||||
await user.click(tab('Références'))
|
||||
await user.click(button('Ajouter une référence'))
|
||||
await keepsTypedValue(
|
||||
user,
|
||||
'tab-reference-new-citation',
|
||||
'Citation',
|
||||
'Ajouter la référence',
|
||||
)
|
||||
})
|
||||
|
||||
it('the region creation form', async () => {
|
||||
const user = await mount()
|
||||
await user.click(tab('Annotations'))
|
||||
|
||||
@@ -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()
|
||||
})
|
||||
})
|
||||
@@ -222,7 +222,7 @@ describe('opening', () => {
|
||||
}
|
||||
})
|
||||
|
||||
it('has no search, no add control; field ids carry the panel prefix', async () => {
|
||||
it('has no search, no add control; « Modifier » opens the reference dialog over the sheet', async () => {
|
||||
const user = await mount()
|
||||
await openFromFinding(user)
|
||||
expect(within(panel()).queryByRole('searchbox')).toBeNull()
|
||||
@@ -231,24 +231,23 @@ describe('opening', () => {
|
||||
).toBeNull()
|
||||
await user.click(within(panel()).getByRole('button', { name: /^Barone/ }))
|
||||
await user.click(within(panel()).getByRole('button', { name: 'Modifier' }))
|
||||
expect(document.querySelectorAll('dialog[open]')).toHaveLength(3)
|
||||
expect(
|
||||
panel().querySelector('#panel-reference-0-ref-a-citation'),
|
||||
).not.toBeNull()
|
||||
expect(document.querySelector('[id^="tab-reference-"]')).toBeNull()
|
||||
screen.getByRole('dialog', { name: 'Modifier la référence' }),
|
||||
).toBeVisible()
|
||||
expect(panel().querySelector('[id$="-citation"]')).toBeNull()
|
||||
})
|
||||
|
||||
it('ids stay unique with the Références tab mounted and the panel open (P14)', async () => {
|
||||
const user = await mount()
|
||||
await user.click(screen.getByRole('tab', { name: 'Références' }))
|
||||
await user.click(screen.getByRole('button', { name: /^Barone/ }))
|
||||
await user.click(screen.getByRole('button', { name: 'Modifier' }))
|
||||
await openFromFinding(user)
|
||||
await user.click(within(panel()).getByRole('button', { name: /^Barone/ }))
|
||||
await user.click(within(panel()).getByRole('button', { name: 'Modifier' }))
|
||||
const ids = [...document.querySelectorAll('[id]')].map((e) => e.id)
|
||||
expect(ids.filter((id, i) => ids.indexOf(id) !== i)).toEqual([])
|
||||
expect(ids).toContain('tab-reference-0-ref-a-citation')
|
||||
expect(ids).toContain('panel-reference-0-ref-a-citation')
|
||||
expect(ids).toContain('tab-reference-0-ref-a-header')
|
||||
expect(ids).toContain('panel-reference-0-ref-a-header')
|
||||
})
|
||||
|
||||
it('read-only: the tiles show, no Modifier, no Retirer, no field', async () => {
|
||||
@@ -348,7 +347,11 @@ describe.each(MODES)('closing, %s', (_label, reduced) => {
|
||||
await focusIs(() =>
|
||||
within(tabPanel).getByRole('heading', { name: 'Références' }),
|
||||
)
|
||||
expect(within(tabPanel).getAllByRole('listitem')).toHaveLength(3)
|
||||
// Filtered by the finding the sheet belonged to: its two citations (R2F-6).
|
||||
expect(within(tabPanel).getAllByRole('listitem')).toHaveLength(2)
|
||||
expect(
|
||||
within(tabPanel).getByText('Références du constat : Node A'),
|
||||
).toBeVisible()
|
||||
})
|
||||
|
||||
it('« Aller à » a citer from a panel tile closes the sheet and opens that finding in its dialog', async () => {
|
||||
@@ -581,90 +584,7 @@ describe('« Retirer de ce constat »', () => {
|
||||
})
|
||||
})
|
||||
|
||||
describe("a tile in edit when the panel closes (P22'')", () => {
|
||||
async function edit(user: User) {
|
||||
await openFromFinding(user)
|
||||
await user.click(within(panel()).getByRole('button', { name: /^Barone/ }))
|
||||
await user.click(within(panel()).getByRole('button', { name: 'Modifier' }))
|
||||
return panel().querySelector(
|
||||
'#panel-reference-0-ref-a-citation',
|
||||
) as HTMLTextAreaElement
|
||||
}
|
||||
|
||||
it('a valid draft is committed before the close, then the panel closes', async () => {
|
||||
const user = await mount()
|
||||
const field = await edit(user)
|
||||
await user.clear(field)
|
||||
await user.type(field, 'Neuf')
|
||||
await user.click(closeButton())
|
||||
expect(doc().references[0].citation).toBe('Neuf')
|
||||
await closed()
|
||||
await focusIs(() => trigger())
|
||||
})
|
||||
|
||||
it('a refused draft cancels a user close: panel open, field focused, message shown', async () => {
|
||||
const user = await mount()
|
||||
const field = await edit(user)
|
||||
await user.clear(field)
|
||||
await user.click(closeButton())
|
||||
expect(hasPanel()).toBe(true)
|
||||
expect(layer()).not.toHaveAttribute('inert')
|
||||
expect(document.activeElement).toBe(field)
|
||||
expect(within(panel()).getByRole('alert')).toBeVisible()
|
||||
expect(doc().references[0].citation).toBe('Barone, Ostéologie')
|
||||
})
|
||||
|
||||
it('a refused draft cancels « Tout afficher »', async () => {
|
||||
const user = await mount()
|
||||
const field = await edit(user)
|
||||
await user.clear(field)
|
||||
await user.click(
|
||||
within(panel()).getByRole('button', {
|
||||
name: "Tout afficher dans l'onglet Références",
|
||||
}),
|
||||
)
|
||||
expect(hasPanel()).toBe(true)
|
||||
})
|
||||
|
||||
it('a forced close (finding vanished) drops a refused draft and says so', async () => {
|
||||
const user = await mount()
|
||||
const field = await edit(user)
|
||||
await user.clear(field)
|
||||
removeNodeA()
|
||||
await closed()
|
||||
await waitFor(() => expect(findingDialog()).toBeNull())
|
||||
await waitFor(() =>
|
||||
expect(live()).toHaveTextContent(/Saisie non appliquée : Citation/),
|
||||
)
|
||||
expect(doc().references[0].citation).toBe('Barone, Ostéologie')
|
||||
})
|
||||
|
||||
it('Escape in a field of the tile neither closes nor commits', async () => {
|
||||
const user = await mount()
|
||||
const field = await edit(user)
|
||||
await user.clear(field)
|
||||
await user.type(field, 'Neuf')
|
||||
await user.keyboard('{Escape}')
|
||||
expect(hasPanel()).toBe(true)
|
||||
expect(doc().references[0].citation).toBe('Barone, Ostéologie')
|
||||
})
|
||||
|
||||
it('a committed tile edit is one entry, reverted by Défaire once the sheet is closed', async () => {
|
||||
const user = await mount()
|
||||
const field = await edit(user)
|
||||
await user.clear(field)
|
||||
await user.type(field, 'Neuf')
|
||||
fireEvent.blur(field)
|
||||
expect(doc().references[0].citation).toBe('Neuf')
|
||||
await user.click(closeButton())
|
||||
await closed()
|
||||
act(() => void store.getState().undoStep())
|
||||
expect(doc().references[0].citation).toBe('Barone, Ostéologie')
|
||||
})
|
||||
})
|
||||
|
||||
const live = () => document.querySelector('p.sr-only[aria-live="polite"]')
|
||||
const entries = () => store.getState().undo.length
|
||||
const undo = () => act(() => store.getState().undoStep())
|
||||
const nodeKey: ElementKey = {
|
||||
kind: 'finding',
|
||||
@@ -689,44 +609,6 @@ function cite(ids: string[]) {
|
||||
})
|
||||
}
|
||||
|
||||
describe('one user edit, one history entry in the panel (C1)', () => {
|
||||
/** Opens Barone, enters edit and types a URL; the field keeps the focus. */
|
||||
async function typeUrl(user: User) {
|
||||
await openFromFinding(user)
|
||||
await user.click(within(panel()).getByRole('button', { name: /^Barone/ }))
|
||||
await user.click(within(panel()).getByRole('button', { name: 'Modifier' }))
|
||||
const url = panel().querySelector<HTMLInputElement>(
|
||||
'#panel-reference-0-ref-a-url',
|
||||
)!
|
||||
await user.type(url, 'https://a.org/')
|
||||
expect(document.activeElement).toBe(url)
|
||||
return entries()
|
||||
}
|
||||
|
||||
it('✕ pressed with the field still focused (iPadOS) adds one entry', async () => {
|
||||
const user = await mount()
|
||||
const before = await typeUrl(user)
|
||||
fireEvent.click(closeButton())
|
||||
await closed()
|
||||
expect(entries() - before).toBe(1)
|
||||
expect(doc().references[0].url).toBe('https://a.org/')
|
||||
undo()
|
||||
expect(doc().references[0].url).toBeNull()
|
||||
})
|
||||
|
||||
it('a forced close (finding vanished) adds the edit once, besides the removal', async () => {
|
||||
const user = await mount()
|
||||
const before = await typeUrl(user)
|
||||
act(() => {
|
||||
store.getState().commit({ op: 'remove', key: nodeKey })
|
||||
})
|
||||
await closed()
|
||||
expect(entries() - before).toBe(2)
|
||||
await waitFor(() => expect(findingDialog()).toBeNull())
|
||||
expect(doc().references[0].url).toBe('https://a.org/')
|
||||
})
|
||||
})
|
||||
|
||||
describe('the panel review fixes', () => {
|
||||
it('the sheet is a modal dialog named by its title (M4: no announcement needed)', async () => {
|
||||
const user = await mount()
|
||||
|
||||
@@ -1,16 +1,15 @@
|
||||
/** R2.1 and R2.2: the Références tab, the library (search, order, counts, add, « Aller à »). */
|
||||
import { afterEach, 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 ReferenceFacts from '@/components/editor/references/ReferenceFacts'
|
||||
import ReferencesTab from '@/components/editor/tabs/ReferencesTab'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { targetOfKey } from '@/editor/navigation'
|
||||
import { edit, insert } from '../helpers/editorFixtures'
|
||||
@@ -22,6 +21,7 @@ import {
|
||||
store,
|
||||
} from '../helpers/editorHarness'
|
||||
import { mountDraft, setWidth } from '../helpers/editorRoute'
|
||||
import ReferencesHost from '../helpers/referencesHost'
|
||||
|
||||
vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
|
||||
vi.mock('@faunosteo/supabase', async (orig) => ({
|
||||
@@ -188,19 +188,19 @@ describe('the Références tab', () => {
|
||||
).toBeNull()
|
||||
})
|
||||
|
||||
it('Ctrl+Z reverts a reference edit', async () => {
|
||||
it('Ctrl+Z reverts a reference edit made in the dialog, once it is closed', async () => {
|
||||
const user = await mount()
|
||||
await user.click(header('Barone'))
|
||||
await user.click(
|
||||
within(tabPanel()).getByRole('button', { name: 'Modifier' }),
|
||||
)
|
||||
const field = within(tabPanel()).getByLabelText('Citation', {
|
||||
selector: '#tab-reference-0-ref-a-citation',
|
||||
})
|
||||
await startEdit(user, 'Barone')
|
||||
const dialog = screen.getByRole('dialog', { name: 'Modifier la référence' })
|
||||
const field = within(dialog).getByLabelText('Citation')
|
||||
await user.clear(field)
|
||||
await user.type(field, 'Neuf')
|
||||
fireEvent.blur(field)
|
||||
const doc = () => JSON.parse(store.getState().documentText)
|
||||
await user.click(
|
||||
within(dialog).getByRole('button', { name: 'Enregistrer' }),
|
||||
)
|
||||
await waitFor(() =>
|
||||
expect(document.querySelector('dialog[open]')).toBeNull(),
|
||||
)
|
||||
expect(doc().references[0].citation).toBe('Neuf')
|
||||
fireEvent.keyDown(document.body, { key: 'z', ctrlKey: true })
|
||||
expect(doc().references[0].citation).toBe('Barone, Ostéologie')
|
||||
@@ -228,13 +228,7 @@ describe('« Aller à » a reference', () => {
|
||||
serverHas(sheetText(), 3)
|
||||
await openReady({ text: sheetText() })
|
||||
const user = userEvent.setup()
|
||||
const view = render(
|
||||
<ReferencesTab
|
||||
readOnly={false}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
/>,
|
||||
)
|
||||
const view = render(<ReferencesHost />)
|
||||
const box = screen.getByRole('searchbox', {
|
||||
name: 'Rechercher une référence',
|
||||
})
|
||||
@@ -244,14 +238,7 @@ describe('« Aller à » a reference', () => {
|
||||
target: targetOfKey({ kind: 'reference', id: 'ref-a' }),
|
||||
serial: 1,
|
||||
}
|
||||
view.rerender(
|
||||
<ReferencesTab
|
||||
readOnly={false}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
focus={focus}
|
||||
/>,
|
||||
)
|
||||
view.rerender(<ReferencesHost focus={focus} />)
|
||||
expect(box).toHaveValue('')
|
||||
expect(document.querySelectorAll('button[aria-controls]')).toHaveLength(3)
|
||||
expect(document.activeElement?.getAttribute('data-focus-key')).toContain(
|
||||
@@ -265,45 +252,17 @@ describe('the reset signal', () => {
|
||||
it('empties the search once per bump and leaves other state alone', async () => {
|
||||
await openReady({ text: sheetText() })
|
||||
const user = userEvent.setup()
|
||||
const view = render(
|
||||
<ReferencesTab
|
||||
readOnly={false}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
libraryReset={0}
|
||||
/>,
|
||||
)
|
||||
const view = render(<ReferencesHost libraryReset={0} />)
|
||||
const box = screen.getByRole('searchbox', {
|
||||
name: 'Rechercher une référence',
|
||||
})
|
||||
await user.type(box, 'Code')
|
||||
view.rerender(
|
||||
<ReferencesTab
|
||||
readOnly={false}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
libraryReset={0}
|
||||
/>,
|
||||
)
|
||||
view.rerender(<ReferencesHost libraryReset={0} />)
|
||||
expect(box).toHaveValue('Code')
|
||||
view.rerender(
|
||||
<ReferencesTab
|
||||
readOnly={false}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
libraryReset={1}
|
||||
/>,
|
||||
)
|
||||
view.rerender(<ReferencesHost libraryReset={1} />)
|
||||
expect(box).toHaveValue('')
|
||||
await user.type(box, 'a')
|
||||
view.rerender(
|
||||
<ReferencesTab
|
||||
readOnly={false}
|
||||
navigate={vi.fn()}
|
||||
reloadSheet={vi.fn()}
|
||||
libraryReset={1}
|
||||
/>,
|
||||
)
|
||||
view.rerender(<ReferencesHost libraryReset={1} />)
|
||||
expect(box).toHaveValue('a')
|
||||
})
|
||||
})
|
||||
@@ -311,182 +270,50 @@ describe('the reset signal', () => {
|
||||
describe('adding a reference', () => {
|
||||
const addButton = () =>
|
||||
within(tabPanel()).getByRole('button', { name: 'Ajouter une référence' })
|
||||
async function add(user: User) {
|
||||
await user.click(addButton())
|
||||
const byId = (id: string) => tabPanel().querySelector<HTMLElement>(id)!
|
||||
await user.selectOptions(byId('#tab-reference-new-type'), 'book')
|
||||
await user.type(byId('#tab-reference-new-citation'), 'Nouvelle source')
|
||||
await user.click(
|
||||
within(tabPanel()).getByRole('button', { name: 'Ajouter la référence' }),
|
||||
)
|
||||
}
|
||||
|
||||
it('resets the search, shows the new tile open and focuses its button', async () => {
|
||||
const user = await mount()
|
||||
await user.type(search(), 'Barone')
|
||||
expect(cards()).toHaveLength(1)
|
||||
await add(user)
|
||||
expect(search()).toHaveValue('')
|
||||
expect(cards()).toHaveLength(4)
|
||||
expect(header('Nouvelle source')).toHaveAttribute('aria-expanded', 'true')
|
||||
expect(document.activeElement).toBe(header('Nouvelle source'))
|
||||
expect(within(tabPanel()).queryByLabelText('Citation')).toBeNull()
|
||||
})
|
||||
|
||||
it('opens a draft tile with the citation focused, and a refused add keeps it', async () => {
|
||||
it('opens the creation dialog with the type to choose, the search untouched', async () => {
|
||||
const user = await mount()
|
||||
await user.type(search(), 'Barone')
|
||||
await user.click(addButton())
|
||||
expect(search()).toHaveValue('')
|
||||
expect(document.activeElement).toBe(
|
||||
tabPanel().querySelector('#tab-reference-new-citation'),
|
||||
)
|
||||
await user.click(
|
||||
within(tabPanel()).getByRole('button', { name: 'Ajouter la référence' }),
|
||||
)
|
||||
expect(within(tabPanel()).getByRole('alert')).toHaveTextContent(
|
||||
'Choisissez un type',
|
||||
)
|
||||
const dialog = screen.getByRole('dialog', { name: 'Nouvelle référence' })
|
||||
expect(within(dialog).getByLabelText('Type')).toHaveValue('')
|
||||
expect(search()).toHaveValue('Barone')
|
||||
expect(doc().references).toHaveLength(3)
|
||||
})
|
||||
})
|
||||
|
||||
describe("« Annuler l'ajout » (C2)", () => {
|
||||
const addButton = () =>
|
||||
within(tabPanel()).getByRole('button', { name: 'Ajouter une référence' })
|
||||
const field = (id: string) =>
|
||||
tabPanel().querySelector<HTMLElement>(`#tab-reference-new-${id}`)!
|
||||
const draftTile = () =>
|
||||
within(tabPanel()).queryByLabelText('Nouvelle référence')
|
||||
const cancelButton = () =>
|
||||
within(tabPanel()).getByRole('button', { name: "Annuler l'ajout" })
|
||||
const history = () => ({
|
||||
undo: store.getState().undo.length,
|
||||
redo: store.getState().redo.length,
|
||||
})
|
||||
const refs = () => JSON.parse(store.getState().documentText).references
|
||||
|
||||
/** One real change undone, so a redo is pending; then the draft is opened. */
|
||||
async function openWithPendingRedo() {
|
||||
it('creates the reference in one modification and leaves the list where it was', async () => {
|
||||
const user = await mount()
|
||||
await startEditAndType(user)
|
||||
act(() => store.getState().undoStep())
|
||||
await user.type(search(), 'Barone')
|
||||
await user.click(addButton())
|
||||
return user
|
||||
}
|
||||
async function startEditAndType(user: User) {
|
||||
await user.click(header('Barone, Ostéologie'))
|
||||
const item = header('Barone, Ostéologie').closest('li')!
|
||||
await user.click(within(item).getByRole('button', { name: 'Modifier' }))
|
||||
await user.type(within(item).getByLabelText('DOI'), '10.1/x')
|
||||
await user.click(within(item).getByRole('button', { name: 'Terminer' }))
|
||||
}
|
||||
function expectCancelled(before: { refs: unknown; history: object }) {
|
||||
expect(draftTile()).toBeNull()
|
||||
expect(refs()).toEqual(before.refs)
|
||||
expect(history()).toEqual(before.history)
|
||||
expect(document.activeElement).toBe(addButton())
|
||||
}
|
||||
const snapshot = () => ({ refs: refs(), history: history() })
|
||||
|
||||
it('the button removes the tile, writes nothing, keeps a pending redo', async () => {
|
||||
const user = await openWithPendingRedo()
|
||||
expect(history().redo).toBe(1)
|
||||
const before = snapshot()
|
||||
await user.click(cancelButton())
|
||||
expectCancelled(before)
|
||||
})
|
||||
|
||||
it('Escape on the type select and on a button does the same', async () => {
|
||||
const user = await openWithPendingRedo()
|
||||
const before = snapshot()
|
||||
await user.type(field('citation'), 'Brouillon')
|
||||
fireEvent.keyDown(field('type'), { key: 'Escape' })
|
||||
expectCancelled(before)
|
||||
await user.click(addButton())
|
||||
await user.type(field('citation'), 'Brouillon')
|
||||
fireEvent.keyDown(cancelButton(), { key: 'Escape' })
|
||||
expectCancelled(before)
|
||||
})
|
||||
|
||||
it('Escape in a field cancels while the form is pristine, not once typed', async () => {
|
||||
const user = await openWithPendingRedo()
|
||||
const before = snapshot()
|
||||
fireEvent.keyDown(field('citation'), { key: 'Escape' })
|
||||
expectCancelled(before)
|
||||
await user.click(addButton())
|
||||
await user.type(field('citation'), 'Brouillon')
|
||||
fireEvent.keyDown(field('citation'), { key: 'Escape' })
|
||||
expect(draftTile()).not.toBeNull()
|
||||
expect(field('citation')).toHaveValue('Brouillon')
|
||||
})
|
||||
|
||||
it('Escape while composing, or already handled, does nothing', async () => {
|
||||
const user = await mount()
|
||||
await user.click(addButton())
|
||||
fireEvent.keyDown(field('type'), { key: 'Escape', isComposing: true })
|
||||
fireEvent.keyDown(field('type'), { key: 'Escape', keyCode: 229 })
|
||||
expect(draftTile()).not.toBeNull()
|
||||
const handled = new KeyboardEvent('keydown', {
|
||||
key: 'Escape',
|
||||
bubbles: true,
|
||||
cancelable: true,
|
||||
})
|
||||
handled.preventDefault()
|
||||
act(() => void field('type').dispatchEvent(handled))
|
||||
expect(draftTile()).not.toBeNull()
|
||||
})
|
||||
|
||||
it('Escape that cancels is marked handled', async () => {
|
||||
const user = await mount()
|
||||
await user.click(addButton())
|
||||
const event = new KeyboardEvent('keydown', {
|
||||
key: 'Escape',
|
||||
bubbles: true,
|
||||
cancelable: true,
|
||||
})
|
||||
act(() => void field('type').dispatchEvent(event))
|
||||
expect(event.defaultPrevented).toBe(true)
|
||||
})
|
||||
|
||||
it('goes with its refusal message, and a new add starts from an empty form', async () => {
|
||||
const user = await mount()
|
||||
await user.click(addButton())
|
||||
await user.type(field('citation'), 'Brouillon')
|
||||
await user.click(
|
||||
within(tabPanel()).getByRole('button', { name: 'Ajouter la référence' }),
|
||||
const dialog = screen.getByRole('dialog', { name: 'Nouvelle référence' })
|
||||
await user.selectOptions(within(dialog).getByLabelText('Type'), 'book')
|
||||
await user.type(
|
||||
within(dialog).getByLabelText('Citation'),
|
||||
'Nouvelle source',
|
||||
)
|
||||
expect(within(tabPanel()).getByRole('alert')).toBeInTheDocument()
|
||||
await user.click(cancelButton())
|
||||
expect(within(tabPanel()).queryByRole('alert')).toBeNull()
|
||||
await user.click(addButton())
|
||||
expect(field('citation')).toHaveValue('')
|
||||
expect(field('type')).toHaveValue('')
|
||||
expect(within(tabPanel()).queryByRole('alert')).toBeNull()
|
||||
})
|
||||
|
||||
it('« Défaire » after a cancel undoes the previous real change', async () => {
|
||||
const user = await mount()
|
||||
await startEditAndType(user)
|
||||
expect(history().undo).toBe(1)
|
||||
await user.click(addButton())
|
||||
await user.click(cancelButton())
|
||||
expect(history().undo).toBe(1)
|
||||
act(() => store.getState().undoStep())
|
||||
expect(history()).toEqual({ undo: 0, redo: 1 })
|
||||
expect(refs()[0].doi).toBeNull()
|
||||
await user.click(
|
||||
within(dialog).getByRole('button', { name: 'Ajouter la référence' }),
|
||||
)
|
||||
await waitFor(() =>
|
||||
expect(document.querySelector('dialog[open]')).toBeNull(),
|
||||
)
|
||||
expect(store.getState().undo.length).toBe(1)
|
||||
expect(doc().references).toHaveLength(4)
|
||||
expect(search()).toHaveValue('Barone')
|
||||
expect(cards()).toHaveLength(1)
|
||||
expect(document.activeElement).toBe(addButton())
|
||||
})
|
||||
})
|
||||
|
||||
const tile = (citation: string) => header(citation).closest('li')!
|
||||
const doc = () => JSON.parse(store.getState().documentText)
|
||||
|
||||
/** Opens the tile and enters edit; answers the tile, whose header then names the edit. */
|
||||
/** Opens the tile and its « Modifier » dialog. */
|
||||
async function startEdit(user: User, citation: string) {
|
||||
const item = tile(citation)
|
||||
await user.click(header(citation))
|
||||
await user.click(within(item).getByRole('button', { name: 'Modifier' }))
|
||||
return item
|
||||
await user.click(
|
||||
within(tile(citation)).getByRole('button', { name: 'Modifier' }),
|
||||
)
|
||||
}
|
||||
|
||||
describe('the tile disclosure', () => {
|
||||
@@ -593,198 +420,6 @@ describe('an open tile', () => {
|
||||
})
|
||||
})
|
||||
|
||||
describe('a tile in edit', () => {
|
||||
it('shows the fields, the citers and « Terminer », and hides the other actions', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const view = within(item)
|
||||
expect(view.getByText('Modifier la référence')).toBeInTheDocument()
|
||||
expect(document.activeElement).toBe(view.getByLabelText('Citation'))
|
||||
expect(view.getByText('Citée 2 fois, par :')).toBeInTheDocument()
|
||||
expect(view.getAllByRole('button', { name: /^Aller à / })).toHaveLength(2)
|
||||
for (const name of ['Modifier', 'Supprimer', 'Monter', 'Descendre']) {
|
||||
expect(view.queryByRole('button', { name })).toBeNull()
|
||||
}
|
||||
await user.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(view.queryByLabelText('Citation')).toBeNull()
|
||||
expect(document.activeElement).toBe(
|
||||
item.querySelector('button[aria-expanded]'),
|
||||
)
|
||||
expect(view.getByRole('button', { name: 'Modifier' })).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('keeps edit and focuses the field when the URL is refused', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const view = within(item)
|
||||
const url = view.getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'exemple.org')
|
||||
await user.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(view.getByRole('button', { name: 'Terminer' })).toBeInTheDocument()
|
||||
expect(document.activeElement).toBe(url)
|
||||
expect(view.getByRole('alert')).toBeInTheDocument()
|
||||
expect(doc().references[0].url).toBeNull()
|
||||
})
|
||||
|
||||
it('keeps edit and focuses the citation when it is left blank', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const view = within(item)
|
||||
const citation = view.getByLabelText('Citation')
|
||||
await user.clear(citation)
|
||||
await user.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(view.getByRole('button', { name: 'Terminer' })).toBeInTheDocument()
|
||||
expect(document.activeElement).toBe(citation)
|
||||
expect(view.getByText('Ce champ est obligatoire.')).toBeInTheDocument()
|
||||
expect(doc().references[0].citation).toBe('Barone, Ostéologie')
|
||||
})
|
||||
|
||||
it('a refused field A, then B applied, then « Terminer » keeps edit', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const view = within(item)
|
||||
const url = view.getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'exemple.org')
|
||||
await user.tab()
|
||||
await user.type(view.getByLabelText('DOI'), '10.1000/xyz')
|
||||
await user.tab()
|
||||
expect(doc().references[0].doi).toBe('10.1000/xyz')
|
||||
await user.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(view.getByRole('button', { name: 'Terminer' })).toBeInTheDocument()
|
||||
expect(document.activeElement).toBe(url)
|
||||
})
|
||||
|
||||
it('a press on « Terminer » keeps the focus in the field (no refusal shifts it), the click keeps edit', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const view = within(item)
|
||||
const url = view.getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'exemple.org')
|
||||
const done = view.getByRole('button', { name: 'Terminer' })
|
||||
await user.pointer({ keys: '[MouseLeft>]', target: done })
|
||||
expect(view.queryByRole('alert')).toBeNull()
|
||||
expect(document.activeElement).toBe(url)
|
||||
await user.pointer({ keys: '[/MouseLeft]', target: done })
|
||||
expect(view.getByRole('alert')).toBeInTheDocument()
|
||||
expect(document.activeElement).toBe(url)
|
||||
expect(view.getByRole('button', { name: 'Terminer' })).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('applies every pending field on « Terminer », as one history entry each', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const view = within(item)
|
||||
const before = store.getState().undo.length
|
||||
await user.type(view.getByLabelText('DOI'), '10.1000/xyz')
|
||||
await user.type(view.getByLabelText('Adresse web (URL)'), 'https://a.org/')
|
||||
await user.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(store.getState().undo.length - before).toBe(2)
|
||||
expect(doc().references[0]).toMatchObject({
|
||||
doi: '10.1000/xyz',
|
||||
url: 'https://a.org/',
|
||||
})
|
||||
expect(view.queryByLabelText('Citation')).toBeNull()
|
||||
})
|
||||
|
||||
it('switching to another tile leaves edit only when the fields apply', async () => {
|
||||
const user = await mount()
|
||||
const barone = await startEdit(user, 'Barone')
|
||||
const denoix = tile('Denoix')
|
||||
const url = within(barone).getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'exemple.org')
|
||||
await user.click(header('Denoix'))
|
||||
const modify = () =>
|
||||
within(denoix).getByRole('button', { name: 'Modifier' })
|
||||
await user.click(modify())
|
||||
expect(within(barone).getByLabelText('Citation')).toBeInTheDocument()
|
||||
expect(within(denoix).queryByLabelText('Citation')).toBeNull()
|
||||
await user.clear(url)
|
||||
await user.click(modify())
|
||||
expect(within(barone).queryByLabelText('Citation')).toBeNull()
|
||||
expect(within(denoix).getByLabelText('Citation')).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('survives a tab change with the typed text', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
await user.type(within(item).getByLabelText('DOI'), '10.1000/kept')
|
||||
await user.click(screen.getByRole('tab', { name: 'Constats' }))
|
||||
await user.click(screen.getByRole('tab', { name: 'Références' }))
|
||||
const view = within(item)
|
||||
expect(view.getByLabelText('DOI')).toHaveValue('10.1000/kept')
|
||||
expect(doc().references[0].doi).toBe('10.1000/kept')
|
||||
})
|
||||
})
|
||||
|
||||
describe('the disclosure button in edit (M7)', () => {
|
||||
it('is named for what it does, and pressing it ends the edit', async () => {
|
||||
const user = await mount()
|
||||
const item = await startEdit(user, 'Barone')
|
||||
const button = within(item).getByRole('button', {
|
||||
name: /^Terminer\. Modifier la référence/,
|
||||
})
|
||||
expect(button).toHaveAttribute('aria-expanded', 'true')
|
||||
await user.click(button)
|
||||
expect(within(item).queryByLabelText('Citation')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('one user edit, one history entry (C1)', () => {
|
||||
const entries = () => store.getState().undo.length
|
||||
const undo = () => act(() => store.getState().undoStep())
|
||||
|
||||
it('« Terminer » after one typed field adds one entry, the first « Défaire » undoes it', async () => {
|
||||
const user = await mount()
|
||||
const view = within(await startEdit(user, 'Barone'))
|
||||
const before = entries()
|
||||
await user.type(view.getByLabelText('Adresse web (URL)'), 'https://a.org/')
|
||||
await user.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(entries() - before).toBe(1)
|
||||
expect(doc().references[0].url).toBe('https://a.org/')
|
||||
undo()
|
||||
expect(doc().references[0].url).toBeNull()
|
||||
})
|
||||
|
||||
it('« Terminer » pressed with the field still focused (no pointer) adds one entry', async () => {
|
||||
const user = await mount()
|
||||
const view = within(await startEdit(user, 'Barone'))
|
||||
const before = entries()
|
||||
const url = view.getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'https://a.org/')
|
||||
expect(document.activeElement).toBe(url)
|
||||
fireEvent.click(view.getByRole('button', { name: 'Terminer' }))
|
||||
expect(entries() - before).toBe(1)
|
||||
undo()
|
||||
expect(doc().references[0].url).toBeNull()
|
||||
})
|
||||
|
||||
it('a tab switch with the field still focused adds one entry', async () => {
|
||||
const user = await mount()
|
||||
const view = within(await startEdit(user, 'Barone'))
|
||||
const before = entries()
|
||||
await user.type(view.getByLabelText('Adresse web (URL)'), 'https://a.org/')
|
||||
fireEvent.click(screen.getByRole('tab', { name: 'Constats' }))
|
||||
expect(entries() - before).toBe(1)
|
||||
undo()
|
||||
expect(doc().references[0].url).toBeNull()
|
||||
})
|
||||
|
||||
it('a blur after the field was applied adds nothing; a changed text adds one more', async () => {
|
||||
const user = await mount()
|
||||
const view = within(await startEdit(user, 'Barone'))
|
||||
const before = entries()
|
||||
const url = view.getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'https://a.org/')
|
||||
await user.tab()
|
||||
await user.click(url)
|
||||
await user.tab()
|
||||
expect(entries() - before).toBe(1)
|
||||
await user.type(url, 'x')
|
||||
await user.tab()
|
||||
expect(entries() - before).toBe(2)
|
||||
})
|
||||
})
|
||||
|
||||
describe('read-only tiles', () => {
|
||||
it('keep DOI, URL and « Aller à », and offer no edit control', async () => {
|
||||
const user = await mount(800)
|
||||
@@ -805,9 +440,8 @@ describe('read-only tiles', () => {
|
||||
})
|
||||
|
||||
describe('reopening the editor', () => {
|
||||
it('starts with every tile closed and none in edit', async () => {
|
||||
it('starts with every tile closed', async () => {
|
||||
const user = await mount()
|
||||
await startEdit(user, 'Barone')
|
||||
await user.click(header('Denoix'))
|
||||
cleanup()
|
||||
await mount()
|
||||
@@ -815,10 +449,5 @@ describe('reopening the editor', () => {
|
||||
expanded: true,
|
||||
})
|
||||
expect(opened).toHaveLength(0)
|
||||
expect(
|
||||
within(tabPanel()).queryByLabelText('Citation', {
|
||||
selector: '#tab-reference-0-ref-a-citation',
|
||||
}),
|
||||
).toBeNull()
|
||||
})
|
||||
})
|
||||
@@ -1,10 +1,15 @@
|
||||
/** R2.3: search, sort, count, no-result notice, A1, the add flow, the pin and the reset. */
|
||||
/** R2.3: search, sort, count, no-result notice, A1, the pin (the dialog's tile) and the reset. */
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { act, cleanup, render, screen, within } from '@testing-library/react'
|
||||
import {
|
||||
act,
|
||||
cleanup,
|
||||
render,
|
||||
screen,
|
||||
waitFor,
|
||||
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'
|
||||
@@ -14,6 +19,7 @@ import {
|
||||
resetStore,
|
||||
store,
|
||||
} from '../helpers/editorHarness'
|
||||
import ReferencesHost from '../helpers/referencesHost'
|
||||
|
||||
vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
|
||||
vi.mock('@faunosteo/supabase', async (orig) => ({
|
||||
@@ -87,12 +93,7 @@ function sortText(): string {
|
||||
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}
|
||||
/>
|
||||
<ReferencesHost readOnly={readOnly} {...extra} />
|
||||
)
|
||||
async function mount(readOnly = false) {
|
||||
await openReady({ text: sortText() })
|
||||
@@ -183,16 +184,6 @@ describe('the count line', () => {
|
||||
})
|
||||
})
|
||||
|
||||
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()
|
||||
@@ -303,96 +294,72 @@ describe('the move buttons (A1)', () => {
|
||||
})
|
||||
})
|
||||
|
||||
/** Opens the tile of `id` and enters edit. */
|
||||
/** Opens the tile of `id` and its « Modifier » dialog. */
|
||||
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
|
||||
return screen.getByRole('dialog', { name: 'Modifier la référence' })
|
||||
}
|
||||
|
||||
describe('the tile in edit is pinned (P23)', () => {
|
||||
it('keeps its index when the sort changes', async () => {
|
||||
/** Types a new citation in the open dialog and saves it. */
|
||||
async function saveCitation(user: User, text: string) {
|
||||
const dialog = screen.getByRole('dialog', { name: 'Modifier la référence' })
|
||||
const citation = within(dialog).getByLabelText('Citation')
|
||||
await user.clear(citation)
|
||||
await user.type(citation, text)
|
||||
await user.click(within(dialog).getByRole('button', { name: 'Enregistrer' }))
|
||||
await waitFor(() => expect(document.querySelector('dialog[open]')).toBeNull())
|
||||
}
|
||||
|
||||
const cancelDialog = async (user: User) => {
|
||||
await user.click(screen.getByRole('button', { name: 'Annuler' }))
|
||||
await waitFor(() => expect(document.querySelector('dialog[open]')).toBeNull())
|
||||
}
|
||||
|
||||
describe('the tile the dialog edits is pinned (P23)', () => {
|
||||
it('keeps its index when the sort changes after the dialog closes', async () => {
|
||||
const { user } = await mount()
|
||||
await user.selectOptions(sortBox(), 'citation')
|
||||
await startEdit(user, 'r1')
|
||||
await cancelDialog(user)
|
||||
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'])
|
||||
expect(order()).toEqual(['r2', 'r1', 'r5', 'r3', 'r4'])
|
||||
})
|
||||
|
||||
it('starts in sheet order and holds its place under a later sort', async () => {
|
||||
it('stays shown under a search it stops matching, until the next search change (I1)', 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 startEdit(user, 'r5')
|
||||
await saveCitation(user, 'Autre titre')
|
||||
expect(order()).toEqual(['r5'])
|
||||
await user.clear(search())
|
||||
await user.type(search(), 'alpha')
|
||||
expect(order()).toEqual(['r5'])
|
||||
expect(order()).toEqual([])
|
||||
})
|
||||
|
||||
it('keeps the tile shown and focused when its edit stops matching the search (I1)', async () => {
|
||||
it('keeps the tile shown and the opener focused when its edit stops matching (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' }))
|
||||
await startEdit(user, 'r1')
|
||||
await saveCitation(user, 'Autre titre')
|
||||
expect(order()).toEqual(['r1', 'r2'])
|
||||
expect(document.activeElement).toBe(header('r1'))
|
||||
expect(search()).toHaveValue('zèbre')
|
||||
expect(document.activeElement).toBe(
|
||||
within(header('r1').closest('li')!).getByRole('button', {
|
||||
name: 'Modifier',
|
||||
}),
|
||||
)
|
||||
})
|
||||
|
||||
it('keeps the tile in edit at its index across a sort change made while read-only (M3)', async () => {
|
||||
it('keeps its index across a sort made in read-only after the dialog', async () => {
|
||||
const { user, view } = await mount()
|
||||
await user.selectOptions(sortBox(), 'citation')
|
||||
await startEdit(user, 'r3')
|
||||
await cancelDialog(user)
|
||||
view.rerender(lib(true))
|
||||
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()
|
||||
})
|
||||
})
|
||||
|
||||
@@ -402,194 +369,74 @@ describe('the tile outside the search (C3)', () => {
|
||||
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 () => {
|
||||
it('after the save shows the tile with its line and no notice', 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' }))
|
||||
await startEdit(user, 'r5')
|
||||
await saveCitation(user, 'Autre titre')
|
||||
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 startEdit(user, 'r5')
|
||||
await saveCitation(user, 'Autre titre')
|
||||
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 user.type(search(), 'zebre')
|
||||
await startEdit(user, 'r1')
|
||||
await user.type(search(), 'alpha')
|
||||
expect(lineOf('r1')).toBeVisible()
|
||||
expect(lineOf('r5')).toBeNull()
|
||||
await user.clear(search())
|
||||
await cancelDialog(user)
|
||||
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')
|
||||
await startEdit(user, 'r5')
|
||||
await saveCitation(user, 'Autre titre')
|
||||
view.rerender(lib(true))
|
||||
expect(order()).toEqual(['r1', 'r5'])
|
||||
expect(lineOf('r1')).toBeVisible()
|
||||
expect(order()).toEqual(['r5'])
|
||||
expect(lineOf('r5')).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 () => {
|
||||
describe('after a dialog closes, the view is unchanged (R2F-5)', () => {
|
||||
it('keeps scroll position inputs: search, sort, open tiles', async () => {
|
||||
const { user } = await mount()
|
||||
await user.selectOptions(sortBox(), 'count')
|
||||
await user.click(header('r2'))
|
||||
await user.selectOptions(sortBox(), 'citation')
|
||||
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', {
|
||||
await startEdit(user, 'r3')
|
||||
await cancelDialog(user)
|
||||
expect(search()).toHaveValue('e')
|
||||
expect(sortBox()).toHaveValue('citation')
|
||||
expect(header('r2')).toHaveAttribute('aria-expanded', 'true')
|
||||
expect(header('r3')).toHaveAttribute('aria-expanded', 'true')
|
||||
expect(document.activeElement).toBe(
|
||||
within(header('r3').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 keeps the sort, keeping open tiles and the tile in edit (R2F-4)', async () => {
|
||||
it('empties the search and keeps the sort, keeping open tiles (R2F-4)', 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 }))
|
||||
@@ -597,10 +444,6 @@ describe('the reset path (« Tout afficher »)', () => {
|
||||
expect(sortBox()).toHaveValue('citation')
|
||||
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'])
|
||||
})
|
||||
})
|
||||
|
||||
@@ -638,9 +481,9 @@ describe('« Aller à » a reference hidden by the search (P3, P8)', () => {
|
||||
})
|
||||
|
||||
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 () => {
|
||||
it('is dropped: undoing the removal brings the tile back closed', async () => {
|
||||
const { user } = await mount()
|
||||
await startEdit(user, 'r4')
|
||||
await user.click(header('r4'))
|
||||
act(() => {
|
||||
store
|
||||
.getState()
|
||||
@@ -652,58 +495,5 @@ describe('state of a reference that left the document (P23-prime)', () => {
|
||||
})
|
||||
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()
|
||||
})
|
||||
})
|
||||
@@ -1,9 +1,14 @@
|
||||
/** Lot F: the Références tab and Vertèbres. */
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { cleanup, render, screen, within } from '@testing-library/react'
|
||||
import {
|
||||
cleanup,
|
||||
render,
|
||||
screen,
|
||||
waitFor,
|
||||
within,
|
||||
} from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import type { AnatomicalSheetDocument } from '@faunosteo/core-wasm/types'
|
||||
import ReferencesTab from '@/components/editor/tabs/ReferencesTab'
|
||||
import RegionsSection from '@/components/editor/annotations/sections/RegionsSection'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { edit, insert, point } from '../helpers/editorFixtures'
|
||||
@@ -13,6 +18,7 @@ import {
|
||||
resetStore,
|
||||
store,
|
||||
} from '../helpers/editorHarness'
|
||||
import ReferencesHost from '../helpers/referencesHost'
|
||||
|
||||
vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) }))
|
||||
vi.mock('@faunosteo/supabase', async (orig) => ({
|
||||
@@ -44,16 +50,24 @@ describe('Références', () => {
|
||||
it('adds a reference only with a type and a citation', async () => {
|
||||
await openReady()
|
||||
const user = userEvent.setup()
|
||||
render(<ReferencesTab {...props} />)
|
||||
render(<ReferencesHost {...props} />)
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: 'Ajouter une référence' }),
|
||||
)
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: 'Ajouter la référence' }),
|
||||
)
|
||||
expect(screen.getByRole('alert')).toHaveTextContent('Choisissez un type')
|
||||
expect(screen.getByLabelText('Type')).toHaveAccessibleDescription(
|
||||
'Ce champ est obligatoire.',
|
||||
)
|
||||
expect(doc().references).toEqual([])
|
||||
await user.selectOptions(screen.getByLabelText('Type'), 'web')
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: 'Ajouter la référence' }),
|
||||
)
|
||||
expect(screen.getByLabelText('Citation')).toHaveAccessibleDescription(
|
||||
'Ce champ est obligatoire.',
|
||||
)
|
||||
await user.type(screen.getByLabelText('Citation'), 'Anatomie du cheval')
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: 'Ajouter la référence' }),
|
||||
@@ -68,23 +82,24 @@ describe('Références', () => {
|
||||
expect(doc().references[0].id).toMatch(/^ref-[a-z2-7]{10}$/)
|
||||
})
|
||||
|
||||
it('edits a field in a tile, applies it on blur, and reorders with the arrows', async () => {
|
||||
it('edits a reference in its dialog, one command on « Enregistrer », and reorders with the arrows', async () => {
|
||||
const text = insert(
|
||||
insert(baseText(), reference('ref-a', 'Alpha')),
|
||||
reference('ref-b', 'Beta'),
|
||||
)
|
||||
await openReady({ text })
|
||||
const user = userEvent.setup()
|
||||
render(<ReferencesTab {...props} />)
|
||||
render(<ReferencesHost {...props} />)
|
||||
await user.click(screen.getByRole('button', { name: /^Alpha/ }))
|
||||
await user.click(screen.getByRole('button', { name: 'Modifier' }))
|
||||
const url = screen.getByLabelText('Adresse web (URL)', {
|
||||
selector: '#tab-reference-0-ref-a-url',
|
||||
})
|
||||
const url = screen.getByLabelText('Adresse web (URL)')
|
||||
await user.type(url, 'https://example.org')
|
||||
await user.tab()
|
||||
expect(doc().references[0].url).toBeNull()
|
||||
await user.click(screen.getByRole('button', { name: 'Enregistrer' }))
|
||||
await waitFor(() =>
|
||||
expect(document.querySelector('dialog[open]')).toBeNull(),
|
||||
)
|
||||
expect(doc().references[0].url).toBe('https://example.org')
|
||||
await user.click(screen.getByRole('button', { name: 'Terminer' }))
|
||||
await user.click(screen.getByRole('button', { name: /^Beta/ }))
|
||||
await user.click(screen.getAllByRole('button', { name: 'Monter' })[1])
|
||||
expect(doc().references.map((r) => r.id)).toEqual(['ref-b', 'ref-a'])
|
||||
@@ -118,7 +133,7 @@ describe('Références', () => {
|
||||
})
|
||||
await openReady({ text })
|
||||
const user = userEvent.setup()
|
||||
render(<ReferencesTab {...props} />)
|
||||
render(<ReferencesHost {...props} />)
|
||||
await user.click(screen.getByRole('button', { name: /^Alpha/ }))
|
||||
expect(screen.queryByRole('button', { name: 'Supprimer' })).toBeNull()
|
||||
expect(screen.getByText(/Pour supprimer cette référence/)).toBeTruthy()
|
||||
@@ -133,7 +148,7 @@ describe('Références', () => {
|
||||
it('read-only shows the facts and no control that changes the draft', async () => {
|
||||
await openReady({ text: insert(baseText(), reference('ref-a', 'Alpha')) })
|
||||
const user = userEvent.setup()
|
||||
render(<ReferencesTab {...props} readOnly />)
|
||||
render(<ReferencesHost {...props} readOnly />)
|
||||
await user.click(screen.getByRole('button', { name: /^Alpha/ }))
|
||||
expect(screen.getByText('Aucun')).toBeTruthy()
|
||||
expect(screen.queryByRole('textbox', { name: 'Citation' })).toBeNull()
|
||||
|
||||
Reference in new issue
Block a user