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).
412 lines
14 KiB
TypeScript
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)
|
|
})
|
|
})
|