Files
faunosteo/apps/app/tests/unit/editor-no-loss-decisions.test.tsx
T
bchanot 51fd3db608 feat(editor): no silent loss on a 1 024 px crossing
Drawing actions stay mounted and hidden while read-only: an upload in
flight, a cleaning candidate, a repair offer and a parent choice come
back on widening. Decision dialogs open only while editing, in a shown
place, references panel closed; otherwise the decision is held per
object, shown as a pending line, reopened by « Reprendre » (absent in
read-only). Picker, file input and parent button are disabled while one
is pending. Repair geometries move into RepairDialog, keyed on the offer.

R-24: no existing assertion rewritten; editor-no-loss-decisions.test.tsx
added (12 cases).
2026-11-06 21:23:46 +01:00

412 lines
14 KiB
TypeScript

/** U1 Lot B2b: the drawing actions of the views section across a crossing and a held decision. */
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 { Annotation } from '@faunosteo/core-wasm/types'
import { cleanSvg } from '@/editor/core/cleaning'
import { useLocaleStore } from '@/state/localeStore'
import { emptyText, insert, point, svgBytes } from '../helpers/editorFixtures'
import {
baseText,
resetStore,
sb,
serverHas,
store,
} from '../helpers/editorHarness'
import {
adminAnswer,
mountDraft,
round,
setWidth,
} from '../helpers/editorRoute'
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(),
registerSheetAsset: vi.fn(),
listSheetAssets: vi.fn(),
uploadSheetDrawing: vi.fn(),
confirmSheetAssetUpload: vi.fn(),
}))
const NEW_ASSET = '22222222-2222-4222-8222-222222222222'
const svg = (inner = '<rect width="4" height="4"/>') =>
`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">${inner}</svg>`
const CLEAN = svg()
const DIRTY = svg(
'<style>.a{fill:red}</style><rect class="a" width="4" height="4"/>',
)
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
const identity = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }
Object.defineProperty(window.SVGElement.prototype, 'getScreenCTM', {
configurable: true,
value: () => ({ ...identity, inverse: () => identity }),
})
})
afterEach(() => {
cleanup()
resetStore()
setWidth(1024)
})
const tab = (name: string | RegExp) => screen.getByRole('tab', { name })
const button = (name: string | RegExp) => screen.getByRole('button', { name })
const maybeButton = (name: string | RegExp) =>
screen.queryByRole('button', { name })
const dialogs = () => document.querySelectorAll('dialog[open]').length
const doc = () => JSON.parse(store.getState().documentText)
const mainAsset = () => doc().views[0].svg_asset_id
const fileInput = (view = 'main') =>
screen.getByTestId(`view-view-${view}-file`) as HTMLInputElement
function cross(width: number) {
act(() => {
setWidth(width)
window.dispatchEvent(new Event('resize'))
})
}
function serverGets(text: string) {
const cleaned = cleanSvg(new TextEncoder().encode(text))
if (!cleaned.ok || !cleaned.value.stored) throw new Error('bad svg')
const bytes = new TextEncoder().encode(cleaned.value.stored)
sb.registerSheetAsset.mockResolvedValue(NEW_ASSET)
sb.listSheetAssets.mockResolvedValue([
{
id: NEW_ASSET,
sha256: cleaned.value.sha256!,
byte_size: cleaned.value.byte_size!,
uploaded_at: null,
},
])
sb.uploadSheetDrawing.mockResolvedValue('uploaded')
sb.confirmSheetAssetUpload.mockResolvedValue(NEW_ASSET)
sb.downloadSheetDrawing.mockImplementation(async (_c, hash) =>
hash === cleaned.value.sha256 ? bytes : svgBytes().bytes,
)
}
/** A file whose bytes arrive when `release` runs: the decision settles at a chosen time. */
function heldFile(text: string) {
let release: () => void = () => undefined
const gate = new Promise<void>((resolve) => (release = resolve))
const file = new File([text], 'd.svg', { type: 'image/svg+xml' })
Object.defineProperty(file, 'arrayBuffer', {
value: async () => {
await gate
return new TextEncoder().encode(text).buffer
},
})
return { file, release }
}
const pick = (file: File, view = 'main') =>
fireEvent.change(fileInput(view), { target: { files: [file] } })
const plain = (text: string) =>
new File([text], 'd.svg', { type: 'image/svg+xml' })
async function mountViews(text = baseText()) {
serverHas(text, 3)
serverGets(CLEAN)
const user = userEvent.setup()
mountDraft()
await screen.findByRole('heading', { level: 1, name: 'Brouillon, version 4' })
await user.click(tab('Annotations'))
await user.click(button('Gérer les vues'))
return user
}
const PENDING = /nettoyage de l'illustration attend votre décision/
const RESUME = 'Reprendre'
describe('a cleaning decision across a crossing', () => {
it('closes with the editor, shows as pending, reopens only through « Reprendre »', async () => {
const user = await mountViews()
serverGets(DIRTY)
pick(plain(DIRTY))
await screen.findByRole('dialog')
cross(800)
await waitFor(() => expect(dialogs()).toBe(0))
expect(screen.getByText(PENDING)).toBeVisible()
expect(maybeButton(RESUME)).toBeNull()
cross(1280)
expect(dialogs()).toBe(0)
expect(screen.getByText(PENDING)).toBeVisible()
await user.click(button(RESUME))
const dialog = within(await screen.findByRole('dialog'))
expect(dialog.getByText('style')).toBeVisible()
await user.click(
dialog.getByRole('button', {
name: 'Nettoyer et utiliser cette version',
}),
)
await waitFor(() => expect(mainAsset()).toBe(NEW_ASSET))
expect(screen.queryByText(PENDING)).toBeNull()
})
it('disables the picker, the file input and the parent button while it is pending', async () => {
const user = await mountViews()
pick(plain(DIRTY))
await screen.findByRole('dialog')
cross(800)
cross(1280)
const picker = button('Choisir une illustration')
expect(picker).toBeDisabled()
expect(fileInput()).toBeDisabled()
const note = screen.getByText(PENDING).closest('[id]')!
expect(picker).toHaveAttribute('aria-describedby', note.id)
await user.click(button(RESUME))
await user.click(
within(await screen.findByRole('dialog')).getByRole('button', {
name: 'Annuler',
}),
)
expect(button('Choisir une illustration')).toBeEnabled()
expect(fileInput()).toBeEnabled()
})
it('a new decision opens on its own once the held one has ended', async () => {
const user = await mountViews()
pick(plain(DIRTY))
await screen.findByRole('dialog')
cross(800)
cross(1280)
await user.click(button(RESUME))
await user.click(
within(await screen.findByRole('dialog')).getByRole('button', {
name: 'Annuler',
}),
)
pick(plain(DIRTY))
expect(await screen.findByRole('dialog')).toBeVisible()
expect(screen.queryByText(PENDING)).toBeNull()
})
it('narrow with a held decision: the pending text, no « Reprendre »; none after widening until clicked', async () => {
const user = await mountViews()
pick(plain(DIRTY))
await screen.findByRole('dialog')
cross(800)
await waitFor(() => expect(dialogs()).toBe(0))
expect(screen.getByText(PENDING)).toBeVisible()
expect(maybeButton(RESUME)).toBeNull()
expect(
screen.queryByRole('button', { name: 'Choisir une illustration' }),
).toBeNull()
cross(1280)
expect(dialogs()).toBe(0)
await user.click(button(RESUME))
expect(await screen.findByRole('dialog')).toBeVisible()
})
})
describe('a decision that settles in a place that is not shown', () => {
it('an offer settling with the section hidden opens nothing until « Reprendre »', async () => {
const user = await mountViews()
const held = heldFile(DIRTY)
pick(held.file)
await user.click(button('Retour au dessin'))
await act(async () => held.release())
await waitFor(() => expect(sb.registerSheetAsset).not.toHaveBeenCalled())
expect(dialogs()).toBe(0)
await user.click(button('Gérer les vues'))
expect(dialogs()).toBe(0)
expect(screen.getByText(PENDING)).toBeVisible()
await user.click(button(RESUME))
expect(await screen.findByRole('dialog')).toBeVisible()
})
it('a widening on another tab opens nothing; the tab keeps its focus', async () => {
const user = await mountViews()
const held = heldFile(DIRTY)
pick(held.file)
await user.click(tab('Général'))
await act(async () => held.release())
cross(800)
cross(1280)
expect(dialogs()).toBe(0)
await user.click(tab('Annotations'))
expect(document.activeElement).toBe(tab('Annotations'))
expect(dialogs()).toBe(0)
expect(screen.getByText(PENDING)).toBeVisible()
})
it('the open references panel holds the decision back, « Reprendre » waits for it to close', async () => {
const user = await mountViews()
const held = heldFile(DIRTY)
pick(held.file)
await user.click(button('Références'))
await act(async () => held.release())
expect(dialogs()).toBe(0)
expect(button(RESUME)).toBeDisabled()
await user.click(button('Références'))
await user.click(button(RESUME))
expect(await screen.findByRole('dialog')).toBeVisible()
})
it('an upload settling while read-only lands in the live hook, its notice shown', async () => {
const user = await mountViews()
let finish: (value: string) => void = () => undefined
sb.registerSheetAsset.mockReturnValue(
new Promise<string>((resolve) => (finish = resolve)),
)
pick(plain(CLEAN))
expect(await screen.findByText(/Vérification et envoi/)).toBeVisible()
cross(800)
expect(screen.getByText(/Vérification et envoi/)).toBeVisible()
await act(async () => finish(NEW_ASSET))
await waitFor(() => expect(mainAsset()).toBe(NEW_ASSET))
expect(store.getState().unsaved).toBe(true)
cross(1280)
expect(await screen.findByText(/est ajoutée à la vue/)).toBeVisible()
void user
})
})
const detailOwn = (assetId: string | null) =>
({
kind: 'view',
value: {
kind: 'detail',
id: 'view-d',
name: { fr: 'Détail', en: 'Detail' },
svg_asset_id: assetId,
view_box: { min_x: 0, min_y: 0, width: 50, height: 50 },
parent_view_id: 'view-main',
},
}) as Parameters<typeof insert>[1]
describe('the parent choice', () => {
const USE_PARENT = "Utiliser l'illustration de la vue parente"
async function mountDetail() {
const user = await mountViews(insert(baseText(), detailOwn(NEW_ASSET)))
return user
}
it('is a decision per click: held across a crossing, a new click opens on its own', async () => {
const user = await mountDetail()
await user.click(button(USE_PARENT))
expect(await screen.findByRole('dialog')).toBeVisible()
cross(800)
await waitFor(() => expect(dialogs()).toBe(0))
expect(
screen.getByText(/retour à l'illustration de la vue parente/),
).toBeVisible()
cross(1280)
expect(button(USE_PARENT)).toBeDisabled()
await user.click(button(RESUME))
await user.click(
within(await screen.findByRole('dialog')).getByRole('button', {
name: 'Annuler',
}),
)
await user.click(button(USE_PARENT))
expect(await screen.findByRole('dialog')).toBeVisible()
})
})
/** An unmeasured main view with annotations far outside a 100 x 100 frame. */
function unmeasuredText(): string {
let text = insert(emptyText(), {
kind: 'category',
value: { id: 'cat-a', name: { fr: 'N', en: 'N' }, color: null },
})
text = insert(text, point('anno-a', 500, 400, 5))
const zone = {
...(point('anno-z', 0, 0, 1).value as Annotation),
kind: 'zone' as const,
geometry: {
type: 'polygon' as const,
points: [
[10, 10],
[400, 10],
[400, 400],
] as [number, number][],
},
}
return insert(text, { kind: 'annotation', value: zone as Annotation })
}
describe('the repair offer', () => {
it('keeps its typed geometries across a crossing and « Reprendre »', async () => {
const user = await mountViews(unmeasuredText())
pick(plain(CLEAN))
const first = await screen.findByRole('dialog')
const row = within(within(first).getByTestId('repair-anno-a'))
const x = row.getByLabelText('Centre x')
await user.clear(x)
await user.type(x, '60{Enter}')
cross(800)
await waitFor(() => expect(dialogs()).toBe(0))
expect(screen.getByText(/réparation des annotations attend/)).toBeVisible()
cross(1280)
expect(dialogs()).toBe(0)
await user.click(button(RESUME))
const again = within(await screen.findByRole('dialog'))
expect(
within(again.getByTestId('repair-anno-a')).getByLabelText('Centre x'),
).toHaveValue('60')
expect(mainAsset()).toBeNull()
})
})
describe('limits of a held decision', () => {
it('is lost with its view (undo), redo does not bring it back', async () => {
const user = await mountViews(baseText())
const added = store.getState().commit({
op: 'insert',
element: detailOwn(null) as never,
} as never)
expect(added.ok).toBe(true)
await screen.findByTestId('view-view-d-file')
pick(plain(DIRTY), 'd')
await screen.findByRole('dialog')
cross(800)
cross(1280)
expect(screen.getByText(PENDING)).toBeVisible()
act(() => void store.getState().undoStep())
await waitFor(() => expect(screen.queryByText(PENDING)).toBeNull())
act(() => void store.getState().redoStep())
await screen.findByTestId('view-view-d-file')
expect(screen.queryByText(PENDING)).toBeNull()
expect(maybeButton(RESUME)).toBeNull()
void user
})
it('stays a pending line without action once the draft is frozen by a submission', async () => {
const user = await mountViews()
const held = heldFile(DIRTY)
pick(held.file)
await user.click(tab(/Vérification/))
await act(async () => held.release())
sb.submitSheetReview.mockResolvedValue('review-1' as never)
await user.type(
screen.getByLabelText('Note de soumission (obligatoire)'),
'Prête',
)
sb.getOfficialSheetAdmin.mockResolvedValue(
adminAnswer({ rounds: [round('open')] }) as never,
)
await user.click(button('Soumettre à la revue'))
await user.click(tab('Annotations'))
await waitFor(() => expect(screen.getByText(PENDING)).toBeVisible())
expect(maybeButton(RESUME)).toBeNull()
expect(dialogs()).toBe(0)
})
})