Header Annuler/Retablir on every tab (aria-disabled, commit on pointerdown, refused blur commit skips the undo). Save line: unsaved count selector (savedDistance), saveLineState forms, server save time via readSaveTime (lastSave in the store, never the browser clock). Discard relabelled and names the stored copy. Tool column pair removed, glyphs in EditorGlyph. Rewritten or removed assertions (R-24): - editor-route.test: Revision 3 / unsaved text / Annuler les modifications -> save-line testid, Abandonner label, copy sentence in the dialog - editor-route-conflict, editor-route-recovery: Revision n and copy_cap/ copy_quota text queries -> save-line testid - editor-no-loss: discard button label - editor-annotations-tab: tool column undo/redo test -> no pair left (behaviour moved to editor-history-buttons.test) - e2e journey/annotations/recovery/structures/support saveDraft/lan: undo/redo and revision/unsaved text -> historyButton, saveLine helpers; structures toHaveCount(0) on old text -> exact Revision n line - editor-shell clickability: header Annuler/Retablir added
334 lines
12 KiB
TypeScript
334 lines
12 KiB
TypeScript
import { fr } from '@/i18n/fr'
|
|
import type { Locator, Page, TestInfo } from '@playwright/test'
|
|
import { expect, expectAccessible, test } from '../support/browser'
|
|
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
|
import {
|
|
bareShape,
|
|
closeReferences,
|
|
editorActor,
|
|
openEditor,
|
|
openReferences,
|
|
openSection,
|
|
pickAnnotation,
|
|
place,
|
|
pointOf,
|
|
revisionText,
|
|
saveDraft,
|
|
saveLine,
|
|
seedDraft,
|
|
selectTab,
|
|
serverDocument,
|
|
serverRevision,
|
|
shapeWith,
|
|
showDrawing,
|
|
} from '../support/editor'
|
|
|
|
// V1-2.6 A4 (contract C9 to C12, C19): the structures around the drawing. Annotation
|
|
// categories, references, vertebral regions, then the findings tree (zones, categories,
|
|
// nodes): add, edit, reorder, mark reviewed, delete with and without dependents.
|
|
|
|
const dict = fr
|
|
|
|
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
|
|
const dialog = (page: Page) => page.getByRole('dialog')
|
|
const button = (page: Page, name: string) =>
|
|
page.getByRole('button', { name, exact: true })
|
|
|
|
async function open(page: Page, ...annotations: unknown[]) {
|
|
const actor = await editorActor('fr')
|
|
const seed = await seedDraft(actor, { shape: shapeWith(...annotations) })
|
|
await openEditor(page, dict, actor, seed.sheetId)
|
|
return { actor, seed }
|
|
}
|
|
|
|
async function commitText(field: Locator, value: string) {
|
|
await field.fill(value)
|
|
await field.press('Enter')
|
|
}
|
|
|
|
test.describe('editor structures (A4)', () => {
|
|
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; phone read-only covered in editor-access
|
|
await routeToSandbox(context)
|
|
})
|
|
test.afterEach(async ({ context }) => {
|
|
await dropLateReplays(context)
|
|
})
|
|
|
|
test('categories, references and regions: add, edit, reorder, delete', async ({
|
|
page,
|
|
requests,
|
|
}) => {
|
|
const { actor, seed } = await open(page)
|
|
requests.forbid(actor.account.email, actor.account.password)
|
|
|
|
// A category added, then renamed in place.
|
|
await openSection(page, dict, 'categories')
|
|
await page.locator('#category-new-fr').fill('Catégorie B')
|
|
await page.locator('#category-new-en').fill('Category B')
|
|
await page
|
|
.getByRole('button', { name: dict['editor.general.category_add'] })
|
|
.click()
|
|
const names = page.locator('[id^="category-"][id$="-name-fr"]')
|
|
await expect(page.locator('#category-new-fr')).toHaveValue('')
|
|
await expect(names).toHaveCount(2)
|
|
await commitText(names.nth(1), 'Catégorie B bis')
|
|
await expect(names.nth(1)).toHaveValue('Catégorie B bis')
|
|
await expectAccessible(page, 'the categories section')
|
|
|
|
// Two references, the second moved up.
|
|
await openReferences(page, dict)
|
|
for (const citation of ['Première référence', 'Seconde référence']) {
|
|
await page.locator('#reference-new-type').selectOption('book')
|
|
await page.locator('#reference-new-citation').fill(citation)
|
|
await page
|
|
.getByRole('button', { name: dict['editor.reference.add'] })
|
|
.click()
|
|
await expect(page.getByText(citation)).toBeVisible()
|
|
}
|
|
const citations = page.locator(
|
|
'[id^="reference-"][id$="-citation"]:not(#reference-new-citation)',
|
|
)
|
|
await expect(citations).toHaveCount(2)
|
|
await expect(
|
|
place(page, 'references').getByText('citée 0 fois'),
|
|
).toHaveCount(2)
|
|
await page
|
|
.getByRole('searchbox', { name: dict['editor.references.search'] })
|
|
.fill('seconde')
|
|
await expect(citations).toHaveCount(1)
|
|
await page
|
|
.getByRole('searchbox', { name: dict['editor.references.search'] })
|
|
.fill('')
|
|
await expect(citations).toHaveCount(2)
|
|
await page
|
|
.getByRole('listitem')
|
|
.filter({ hasText: 'Seconde référence' })
|
|
.getByRole('button', { name: dict['editor.action.move_up'] })
|
|
.click()
|
|
await expect(citations.first()).toHaveValue('Seconde référence')
|
|
await page
|
|
.getByRole('listitem')
|
|
.filter({ hasText: 'Première référence' })
|
|
.getByRole('button', { name: dict['editor.action.delete'] })
|
|
.click()
|
|
await dialog(page)
|
|
.getByRole('button', { name: dict['editor.delete.confirm'] })
|
|
.click()
|
|
await expect(citations).toHaveCount(1)
|
|
|
|
// A region with its count.
|
|
await closeReferences(page, dict)
|
|
await openSection(page, dict, 'regions')
|
|
await page.locator('#region-new-code').fill('T')
|
|
await page.locator('#region-new-fr').fill('Thoracique')
|
|
await page.locator('#region-new-en').fill('Thoracic')
|
|
await page.locator('#region-new-count').fill('18')
|
|
await page
|
|
.getByRole('button', { name: dict['editor.vertebra.add'] })
|
|
.click()
|
|
await commitText(page.locator('#region-T-count'), '17')
|
|
await expect(page.locator('#region-T-count')).toHaveValue('17')
|
|
|
|
await saveDraft(page, dict, seed.revision + 1)
|
|
const saved = await serverDocument<{
|
|
categories: { name: { fr: string } }[]
|
|
references: { citation: string }[]
|
|
vertebral_config: { regions: { code: string; count: number }[] }
|
|
}>(seed.draftId)
|
|
expect(saved.categories.map((c) => c.name.fr)).toEqual([
|
|
'Catégorie A',
|
|
'Catégorie B bis',
|
|
])
|
|
expect(saved.references.map((r) => r.citation)).toEqual([
|
|
'Seconde référence',
|
|
])
|
|
expect(saved.vertebral_config.regions).toEqual([
|
|
expect.objectContaining({ code: 'T', count: 17 }),
|
|
])
|
|
})
|
|
|
|
test('the findings tree: add zone, category and node, review, reorder', async ({
|
|
page,
|
|
requests,
|
|
}) => {
|
|
const { actor, seed } = await open(page)
|
|
requests.forbid(actor.account.email, actor.account.password)
|
|
await selectTab(page, dict, 'findings')
|
|
const items = page.getByTestId('finding-item')
|
|
// The seeded zone is open: the zone and its category show, the node is folded.
|
|
await expect(items).toHaveCount(2)
|
|
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.add_zone'] })
|
|
.click()
|
|
await page.locator('#finding-new-name-fr').fill('Zone B')
|
|
await page.locator('#finding-new-name-en').fill('Zone B en')
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.create'] })
|
|
.click()
|
|
await expect(items.filter({ hasText: 'Zone B' })).toBeVisible()
|
|
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.add_category'] })
|
|
.click()
|
|
await page.locator('#finding-new-zone').selectOption({ label: 'Zone B' })
|
|
await page.locator('#finding-new-kind').selectOption('anamnesis')
|
|
await page.locator('#finding-new-name-fr').fill('Anamnèse B')
|
|
await page.locator('#finding-new-name-en').fill('History B')
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.create'] })
|
|
.click()
|
|
const category = items.filter({ hasText: 'Anamnèse B' })
|
|
await expect(category).toBeVisible()
|
|
await expect(
|
|
category.getByText(dict['editor.findings.status.to_confirm']),
|
|
).toBeVisible()
|
|
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.add_node'] })
|
|
.click()
|
|
await page.locator('#finding-new-name-fr').fill('Constat B1')
|
|
await page.locator('#finding-new-name-en').fill('Finding B1')
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.create'] })
|
|
.click()
|
|
const node = items.filter({ hasText: 'Constat B1' })
|
|
await expect(node).toBeVisible()
|
|
|
|
// Marked reviewed: the badge of the row follows.
|
|
await page
|
|
.getByRole('button', { name: dict['editor.findings.mark_reviewed'] })
|
|
.click()
|
|
await expect(
|
|
node.getByText(dict['editor.findings.status.reviewed']),
|
|
).toBeVisible()
|
|
// The tab row (history buttons included) scrolled under the sticky top bar is not a
|
|
// target-size finding of its own: audit it from the top.
|
|
await page.evaluate(() => window.scrollTo(0, 0))
|
|
await expectAccessible(page, 'the findings tree')
|
|
|
|
// Reorder: the new zone moves above the seeded one.
|
|
await items.filter({ hasText: 'Zone B' }).first().click()
|
|
await page
|
|
.getByRole('button', { name: dict['editor.action.move_up'] })
|
|
.click()
|
|
await expect(items.first()).toContainText('Zone B')
|
|
|
|
await saveDraft(page, dict, seed.revision + 1)
|
|
const saved = await serverDocument<{
|
|
finding_zones: { name: { fr: string } }[]
|
|
}>(seed.draftId)
|
|
expect(saved.finding_zones.map((z) => z.name.fr)).toEqual([
|
|
'Zone B',
|
|
'Zone A',
|
|
])
|
|
})
|
|
|
|
test('a draft stored with bare nodes loads filled: rename, save, reload clean', async ({
|
|
page,
|
|
requests,
|
|
}) => {
|
|
const actor = await editorActor('fr')
|
|
requests.forbid(actor.account.email, actor.account.password)
|
|
const seed = await seedDraft(actor, { shape: bareShape })
|
|
await openEditor(page, dict, actor, seed.sheetId)
|
|
await selectTab(page, dict, 'findings')
|
|
const items = page.getByTestId('finding-item')
|
|
await items.filter({ hasText: 'Catégorie nue' }).click()
|
|
await commitText(page.locator('#finding-name-fr'), 'Catégorie renommée')
|
|
await saveDraft(page, dict, seed.revision + 1)
|
|
|
|
const saved = await serverDocument<{
|
|
finding_zones: { categories: { reference_ids: string[] }[] }[]
|
|
}>(seed.draftId)
|
|
expect(saved.finding_zones[0].categories[0].reference_ids).toEqual([])
|
|
expect(await serverRevision(seed.draftId)).toBe(seed.revision + 1)
|
|
|
|
await page.reload()
|
|
await selectTab(page, dict, 'findings')
|
|
await expect(items.filter({ hasText: 'Catégorie renommée' })).toBeVisible()
|
|
await expect(saveLine(page)).toHaveText(
|
|
revisionText(dict, seed.revision + 1),
|
|
)
|
|
await expect(
|
|
button(page, dict['editor.draft.recovery.restore']),
|
|
).toHaveCount(0)
|
|
})
|
|
|
|
test('delete with dependents: refused with the list; without, descendants named', async ({
|
|
page,
|
|
requests,
|
|
}) => {
|
|
const { actor } = await open(
|
|
page,
|
|
pointOf('p1', 'main', { cx: 500, cy: 400, r: 40 }, 'Point lié'),
|
|
)
|
|
requests.forbid(actor.account.email, actor.account.password)
|
|
|
|
// The category is used by the point: the dialog lists it and offers no deletion.
|
|
await openSection(page, dict, 'categories')
|
|
await page
|
|
.getByRole('listitem')
|
|
.filter({ has: page.locator('#category-cat-a-name-fr') })
|
|
.getByRole('button', { name: dict['editor.action.delete'] })
|
|
.click()
|
|
await expect(
|
|
dialog(page).getByText(
|
|
dict['editor.delete.blocked'].replace('{name}', 'Catégorie A'),
|
|
),
|
|
).toBeVisible()
|
|
await expect(dialog(page).getByText('Point lié')).toBeVisible()
|
|
await expect(
|
|
dialog(page).getByRole('button', { name: dict['editor.delete.confirm'] }),
|
|
).toHaveCount(0)
|
|
await dialog(page)
|
|
.getByRole('button', { name: dict['editor.delete.close'], exact: true })
|
|
.last()
|
|
.click()
|
|
|
|
// The zone is linked by the point as well: refused.
|
|
await selectTab(page, dict, 'findings')
|
|
const zone = page.getByTestId('finding-item').filter({ hasText: 'Zone A' })
|
|
await zone.first().click()
|
|
await page
|
|
.getByRole('button', { name: dict['editor.action.delete'] })
|
|
.click()
|
|
await expect(
|
|
dialog(page).getByText(
|
|
dict['editor.delete.blocked'].replace('{name}', 'Zone A'),
|
|
),
|
|
).toBeVisible()
|
|
await dialog(page)
|
|
.getByRole('button', { name: dict['editor.delete.close'], exact: true })
|
|
.last()
|
|
.click()
|
|
|
|
// The point goes first; the zone then deletes with its descendants named.
|
|
await showDrawing(page, dict)
|
|
await pickAnnotation(page, dict, /Point lié/)
|
|
await page
|
|
.getByTestId('annotation-properties')
|
|
.getByRole('button', { name: dict['editor.action.delete'] })
|
|
.click()
|
|
await dialog(page)
|
|
.getByRole('button', { name: dict['editor.delete.confirm'] })
|
|
.click()
|
|
await selectTab(page, dict, 'findings')
|
|
await zone.first().click()
|
|
await page
|
|
.getByRole('button', { name: dict['editor.action.delete'] })
|
|
.click()
|
|
await expect(
|
|
dialog(page).getByText(dict['editor.delete.descendants']),
|
|
).toBeVisible()
|
|
await expect(dialog(page).getByText('Dysfonction A')).toBeVisible()
|
|
await dialog(page)
|
|
.getByRole('button', { name: dict['editor.delete.confirm'] })
|
|
.click()
|
|
await expect(page.getByTestId('finding-item')).toHaveCount(0)
|
|
await expect(page.getByText(dict['editor.findings.empty'])).toBeVisible()
|
|
})
|
|
})
|