Files
bchanot 10413478fb test(app): every shell suite drops late replays after a test
The client journey could fail after it passed: since V1-1.6 the client page
reloads its animals after a restore, and that replay outlived the test. One
support helper unroutes without waiting, for the three shell specs. Found by
the V1-1.6 verifier. Memory: BDR-079, LRN-087 to 089.
2026-10-26 17:38:52 +01:00

1032 lines
37 KiB
TypeScript

import { randomUUID } from 'node:crypto'
import { en } from '@/i18n/en'
import { fr } from '@/i18n/fr'
import type { Dict } from '@/i18n/types'
import { formatDate } from '@/lib/dates'
import type { Locator, Page, TestInfo } from '@playwright/test'
import { sql } from '../../../../packages/supabase/tests/sandbox/stack'
import {
expect,
expectAccessible,
expectNoHorizontalOverflow,
test,
} from '../support/browser'
import {
createAccount,
dropLateReplays,
routeToSandbox,
sandboxUrl,
} from '../support/sandbox'
import {
literal,
seedAnimal,
seedClient,
seedRelation,
} from '../support/records'
import { signIn } from '../support/shell'
// V1-1.6 animals and relations on the isolated stack: contract §11.2 journeys
// 1 to 7 and the owner brief's list (empty list, creation with and without a
// client, search, species filter, edit, concurrent edit, archive and restore,
// first animal from a client page, linking an existing animal, co-owners, the
// end and the voiding of a relation, a refused duplicate, two accounts, a
// change of session, keyboard only, a retry after a lost answer, network
// failures, a change of language), in FR and EN, desktop and 375 px, axe on
// every state. Every fixture is fictitious and made per test.
const LANGUAGES = [
['fr', fr],
['en', en],
] as const
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
const tagOf = () => randomUUID().slice(0, 8)
/** Follows an entry of the shell's navigation: the sidebar, or the drawer on a phone. */
async function navigate(page: Page, dict: Dict, info: TestInfo, key: string) {
if (isPhone(info)) {
await page.getByRole('button', { name: dict['shell.open_menu'] }).click()
await page
.getByRole('dialog', { name: dict['shell.nav_label'] })
.getByRole('navigation')
.getByRole('link', { name: dict[key] })
.click()
} else {
await page
.getByRole('navigation', { name: dict['shell.nav_label'] })
.getByRole('link', { name: dict[key] })
.click()
}
}
async function openAnimals(page: Page, dict: Dict, info: TestInfo) {
await navigate(page, dict, info, 'shell.nav.animals')
await expect(page).toHaveURL(/\/app\/animals$/)
await expect(heading(page, dict['animals.list.title'])).toBeFocused()
}
async function signOut(page: Page, dict: Dict, info: TestInfo) {
if (isPhone(info)) {
await page.getByRole('button', { name: dict['shell.open_menu'] }).click()
await page
.getByRole('dialog', { name: dict['shell.nav_label'] })
.getByRole('button', { name: dict['shell.sign_out'] })
.click()
} else {
await page.getByRole('button', { name: dict['shell.sign_out'] }).click()
}
await expect(page).toHaveURL(/\/$/)
}
const heading = (page: Page, name: string) =>
page.getByRole('main').getByRole('heading', { level: 1, name })
const listRows = (page: Page, dict: Dict) =>
page
.getByRole('list', { name: dict['animals.list.results_label'] })
.getByRole('listitem')
const relationsCard = (page: Page) =>
page.locator('section[aria-labelledby="animal-relations-title"]')
/** The accessible name of a relation action: « Terminer : Marie Dupont, propriétaire ». */
const actionName = (
dict: Dict,
action: string,
client: string,
roleKey: string,
) =>
dict['relations.action_named']
.replace('{action}', dict[action])
.replace('{name}', client)
.replace('{role}', dict[roleKey].toLowerCase())
/** Picks a record in the in-page search of a relation panel or of the form. */
async function pick(scope: Page | Locator, label: string, term: string) {
await scope.getByRole('searchbox', { name: label }).fill(term)
await scope.getByRole('button', { name: new RegExp(`^${term}`) }).click()
}
const count = (query: string) => sql(`select count(*) from ${query}`)
/**
* axe from the top of the page: a state reached at the bottom of a phone page
* leaves the first controls under the sticky top bar, which axe's target-size
* rule measures as cut; at rest on the page nothing sits under the bar.
*/
async function expectAccessibleFromTop(page: Page, state: string) {
await page.evaluate(() => window.scrollTo(0, 0))
await expectAccessible(page, state)
}
for (const [locale, dict] of LANGUAGES) {
test.describe(`animals (${locale})`, () => {
test.use({ locale: locale === 'fr' ? 'fr-FR' : 'en-GB' })
test.beforeEach(async ({ context }) => {
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('empty list, an « Autre » with no owner, search, species filter, edit, archive, archived filter, restore', async ({
page,
requests,
}, info) => {
const tag = tagOf()
const name = `Furet Fictif ${tag}`
const horse = `Cheval Témoin ${tag}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
name,
horse,
tag,
'Furet',
'Albinos',
)
await signIn(page, account, dict)
await openAnimals(page, dict, info)
await expect(page.getByText(dict['animals.list.empty'])).toBeVisible()
await expectAccessible(page, 'the empty animal list')
await expectNoHorizontalOverflow(page, 'the empty animal list')
await page.getByRole('link', { name: dict['animals.list.new'] }).click()
await expect(page).toHaveURL(/\/app\/animals\/new$/)
await expect(
heading(page, dict['animals.form.create_title']),
).toBeFocused()
for (const sex of ['male', 'female', 'unknown'])
await expect(
page.getByRole('radio', {
name: dict[`animals.sex.${sex}`],
exact: true,
}),
).not.toBeChecked()
const species = page.getByRole('combobox', {
name: dict['animals.form.species'],
})
await expect(species).toHaveValue('')
await expectAccessible(page, 'the new animal form')
await expectNoHorizontalOverflow(page, 'the new animal form')
await page.getByLabel(dict['animals.form.name']).fill(name)
await species.selectOption('other')
await page.getByLabel(dict['animals.form.species_detail']).fill('Furet')
await page
.getByRole('radio', { name: dict['animals.sex.unknown'], exact: true })
.check()
const year = page.getByLabel(dict['animals.form.birth_year'])
const date = page.getByLabel(dict['animals.form.birth_date'])
await year.fill('2020')
await date.fill('2021-06-15')
await expect(year).toHaveValue('2021')
await expect(year).toHaveAttribute('readonly', '')
await date.fill('')
await expect(year).toHaveValue('2021')
await expect(year).not.toHaveAttribute('readonly', '')
await date.fill('2021-06-15')
await expectAccessible(page, 'the filled animal form')
await page
.getByRole('button', { name: dict['animals.form.submit_create'] })
.click()
await expect(page).toHaveURL(/\/app\/animals\/[0-9a-f-]{36}$/)
await expect(heading(page, name)).toBeFocused()
await expect(page.getByText(dict['animals.detail.created'])).toBeVisible()
const main = page.getByRole('main')
await expect(main).toContainText(
`${locale === 'fr' ? 'Autre' : 'Other'} (Furet)`,
)
await expect(main).toContainText(
dict['animals.detail.birth_on'].replace(
'{date}',
formatDate('2021-06-15', locale),
),
)
await expect(page.getByText(dict['animals.no_owner'])).toBeVisible()
await expect(page.getByText(dict['relations.none'])).toBeVisible()
await expectAccessible(page, 'the animal page')
await expectNoHorizontalOverflow(page, 'the animal page')
await page
.getByRole('link', { name: dict['animals.detail.edit'] })
.click()
await expect(page.getByLabel(dict['animals.form.name'])).toHaveValue(name)
await expect(
page.getByRole('radio', {
name: dict['animals.sex.unknown'],
exact: true,
}),
).toBeChecked()
await page.getByLabel(dict['animals.form.breed']).fill('Albinos')
await page
.getByRole('button', {
name: dict['animals.form.submit_update'],
exact: true,
})
.click()
await expect(page.getByText(dict['animals.detail.updated'])).toBeVisible()
await expect(main).toContainText('Albinos')
await seedAnimal(account, horse)
await page
.getByRole('link', { name: dict['animals.detail.back'] })
.click()
await expect(listRows(page, dict)).toHaveCount(2)
const search = page.getByRole('searchbox', {
name: dict['animals.list.search_label'],
})
await search.fill(`furet fictif ${tag}`)
await expect(listRows(page, dict)).toHaveCount(1)
await expect(listRows(page, dict).first()).toContainText(name)
await expect(listRows(page, dict).first()).toContainText(
dict['animals.no_owner'],
)
await search.fill('albinos')
await expect(listRows(page, dict)).toHaveCount(1)
await search.fill('')
const filter = page.getByRole('combobox', {
name: dict['animals.list.species_filter'],
})
await filter.selectOption('equine')
await expect(listRows(page, dict)).toHaveCount(1)
await expect(listRows(page, dict).first()).toContainText(horse)
await filter.selectOption('other')
await expect(listRows(page, dict)).toHaveCount(1)
await expect(listRows(page, dict).first()).toContainText(name)
await filter.selectOption('canine')
await expect(
page.getByText(dict['animals.list.no_results']),
).toBeVisible()
await expectAccessible(page, 'a filtered animal list')
await filter.selectOption('')
await expect(listRows(page, dict)).toHaveCount(2)
await listRows(page, dict)
.filter({ hasText: name })
.getByRole('link')
.click()
const archive = page.getByRole('button', {
name: dict['animals.detail.archive'],
})
await archive.click()
const dialog = page.getByRole('dialog', {
name: dict['animals.archive.title'],
})
await expect(dialog).toHaveAccessibleDescription(
dict['animals.archive.body'],
)
await expectAccessible(page, 'the animal archive confirmation')
await page.keyboard.press('Escape')
await expect(dialog).toBeHidden()
await expect(archive).toBeFocused()
await archive.click()
await dialog
.getByRole('button', {
name: dict['animals.archive.confirm'],
exact: true,
})
.click()
await expect(dialog).toBeHidden()
await expect(
page.getByText(dict['animals.detail.archived'], { exact: true }),
).toBeVisible()
await expect(
page.getByText(dict['animals.detail.archived_notice']),
).toBeVisible()
await expect(
page.getByRole('link', { name: dict['animals.detail.edit'] }),
).toHaveCount(0)
await expect(
page.getByRole('button', { name: dict['relations.add_client'] }),
).toHaveCount(0)
expect(
await sql(
`select archived_at is not null from public.animals where name = ${literal(name)}`,
),
).toBe('t')
await page
.getByRole('link', { name: dict['animals.detail.back'] })
.click()
await expect(listRows(page, dict)).toHaveCount(1)
await page
.getByRole('switch', { name: dict['animals.list.archived_toggle'] })
.check()
await expect(listRows(page, dict)).toHaveCount(1)
await expect(listRows(page, dict).first()).toContainText(
dict['animals.archived_badge'],
)
await expectAccessible(page, 'the archived animals')
await listRows(page, dict).first().getByRole('link').click()
await page
.getByRole('button', { name: dict['animals.detail.restore'] })
.click()
await expect(
page.getByText(dict['animals.detail.restored']),
).toBeVisible()
await expect(
page.getByRole('link', { name: dict['animals.detail.edit'] }),
).toBeVisible()
// The relations are read again for the restored animal: editable again.
await expect(
relationsCard(page).getByRole('button', {
name: dict['relations.add_client'],
}),
).toBeVisible()
await expect(page.getByText(dict['relations.none'])).toBeVisible()
})
test('pages of 25 with « Afficher plus », in name order', async ({
page,
requests,
}, info) => {
const account = await createAccount(locale, false)
requests.forbid(account.email, account.password, account.displayName)
const ws = await sql(
`select id from public.workspaces where personal_user_id = ${literal(account.id)}`,
)
await sql(`insert into public.animals (workspace_id, name, species_id, sex, create_request_id, create_request_digest)
select ${literal(ws)}, 'Animal Paginé ' || lpad(i::text, 2, '0'), 'canine', 'male', gen_random_uuid(), '\\x00'
from generate_series(1, 30) i`)
await signIn(page, account, dict)
await openAnimals(page, dict, info)
await expect(listRows(page, dict)).toHaveCount(25)
await expect(listRows(page, dict).first()).toContainText(
'Animal Paginé 01',
)
await expect(listRows(page, dict).nth(24)).toContainText(
'Animal Paginé 25',
)
await page
.getByRole('button', { name: dict['animals.list.more'] })
.click()
await expect(listRows(page, dict)).toHaveCount(30)
await expect(listRows(page, dict).nth(29)).toContainText(
'Animal Paginé 30',
)
await expect(
page.getByRole('button', { name: dict['animals.list.more'] }),
).toHaveCount(0)
await expectNoHorizontalOverflow(page, 'a long animal list')
})
test('from a client page: a first animal pre-associated as owner, then an existing animal linked', async ({
page,
requests,
}) => {
const tag = tagOf()
const client = `Marie Fictive ${tag}`
const filly = `Pouliche Fictive ${tag}`
const existing = `Cheval Existant ${tag}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
client,
filly,
existing,
tag,
'612345678',
)
const clientId = await seedClient(account, client, {
phone: '+33612345678',
})
await seedAnimal(account, existing)
await signIn(page, account, dict)
await page.goto(`/app/clients/${clientId}`)
await expect(heading(page, client)).toBeFocused()
await expect(page.getByText(dict['clients.animals.none'])).toBeVisible()
await page
.getByRole('link', { name: dict['clients.animals.add_first'] })
.click()
await expect(page).toHaveURL(/\/app\/animals\/new$/)
await expect(
heading(page, dict['animals.form.create_title']),
).toBeFocused()
await expect(page.getByRole('main')).toContainText(client)
for (const role of ['owner', 'keeper', 'contact'])
await expect(
page.getByRole('radio', {
name: dict[`clients.role.${role}`],
exact: true,
}),
).not.toBeChecked()
await expectAccessible(page, 'the animal form with its client')
await page.getByLabel(dict['animals.form.name']).fill(filly)
await page
.getByRole('combobox', { name: dict['animals.form.species'] })
.selectOption('equine')
await page
.getByRole('radio', { name: dict['animals.sex.female'], exact: true })
.check()
const submit = page.getByRole('button', {
name: dict['animals.form.submit_create'],
})
await submit.click()
await expect(page.getByText(dict['animals.error.role'])).toBeVisible()
await expect(
page.getByRole('radio', {
name: dict['clients.role.owner'],
exact: true,
}),
).toBeFocused()
await page
.getByRole('radio', { name: dict['clients.role.owner'], exact: true })
.check()
await submit.click()
await expect(page).toHaveURL(new RegExp(`/app/clients/${clientId}$`))
await expect(
page.getByText(dict['clients.detail.animal_added']),
).toBeVisible()
await expect(page.getByRole('link', { name: filly })).toBeVisible()
await expect(page.getByRole('main')).toContainText(
dict['clients.role.owner'],
)
expect(
await count(
`public.animal_client_relations r join public.animals a on a.id = r.animal_id
where a.name = ${literal(filly)} and r.client_id = ${literal(clientId)}
and r.relation_role = 'owner' and r.ended_at is null and r.voided_at is null`,
),
).toBe('1')
const link = page.getByRole('button', {
name: dict['clients.animals.link_existing'],
})
await link.click()
const panel = page.getByRole('form', {
name: dict['relations.panel.title_animal'],
})
await expect(
panel.getByRole('heading', {
name: dict['relations.panel.title_animal'],
}),
).toBeFocused()
await pick(panel, dict['relations.picker.animal_label'], existing)
await panel
.getByRole('radio', { name: dict['clients.role.keeper'], exact: true })
.check()
await panel
.getByLabel(dict['relations.panel.started_on'])
.fill('2024-03-01')
await expectAccessible(page, 'the link-an-animal panel')
await expectNoHorizontalOverflow(page, 'the link-an-animal panel')
await panel
.getByRole('button', { name: dict['relations.panel.save_animal'] })
.click()
await expect(page.getByText(dict['relations.added_animal'])).toBeVisible()
await expect(link).toBeFocused()
await expect(page.getByRole('link', { name: existing })).toBeVisible()
await expect(page.getByRole('main')).toContainText(
dict['clients.animals.since'].replace(
'{date}',
formatDate('2024-03-01', locale),
),
)
await expectAccessibleFromTop(page, 'the client page with its animals')
await page.getByRole('link', { name: filly }).click()
await expect(heading(page, filly)).toBeFocused()
const card = relationsCard(page)
await expect(card.getByRole('link', { name: client })).toBeVisible()
await expect(
card.getByRole('link', { name: '+33612345678' }),
).toHaveAttribute('href', 'tel:+33612345678')
await expect(page.getByText(dict['animals.no_owner'])).toHaveCount(0)
})
test('animal page: co-owners, a keeper structure, a duplicate refused, a mistake voided, the sale ended with its date', async ({
page,
requests,
}) => {
const tag = tagOf()
const mare = `Jument Vendue ${tag}`
const former = `Ancien Propriétaire ${tag}`
const buyer = `Nouvelle Propriétaire ${tag}`
const stable = `Écurie du Lac ${tag}`
const wrong = `Client Erroné ${tag}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
mare,
former,
buyer,
stable,
wrong,
tag,
)
const animalId = await seedAnimal(account, mare)
const formerId = await seedClient(account, former)
await seedClient(account, buyer)
await seedClient(account, stable, { kind: 'organization' })
await seedClient(account, wrong)
await seedRelation(account, animalId, formerId, 'owner', '2018-04-01')
await signIn(page, account, dict)
await page.goto(`/app/animals/${animalId}`)
await expect(heading(page, mare)).toBeFocused()
const card = relationsCard(page)
const add = card.getByRole('button', {
name: dict['relations.add_client'],
})
async function link(clientName: string, roleKey: string) {
await add.click()
const panel = page.getByRole('form', {
name: dict['relations.panel.title_client'],
})
await pick(panel, dict['relations.picker.client_label'], clientName)
await panel
.getByRole('radio', { name: dict[roleKey], exact: true })
.check()
await panel
.getByRole('button', { name: dict['relations.panel.save_client'] })
.click()
return panel
}
await link(buyer, 'clients.role.owner')
await expect(page.getByText(dict['relations.added_client'])).toBeVisible()
await expect(add).toBeFocused()
const current = card.locator(
'section[aria-labelledby="animal-relations-current"]',
)
await expect(current.getByRole('link', { name: former })).toBeVisible()
await expect(current.getByRole('link', { name: buyer })).toBeVisible()
const duplicate = await link(buyer, 'clients.role.owner')
await expect(
duplicate.getByText(dict['relations.failure.duplicate_relation']),
).toBeVisible()
await expectAccessibleFromTop(page, 'a refused duplicate')
await duplicate
.getByRole('button', { name: dict['common.cancel'] })
.click()
await expect(add).toBeFocused()
await link(stable, 'clients.role.keeper')
await expect(current.getByRole('link', { name: stable })).toBeVisible()
await link(wrong, 'clients.role.contact')
await expect(current.getByRole('link', { name: wrong })).toBeVisible()
await card
.getByRole('button', {
name: actionName(
dict,
'relations.void.action',
wrong,
'clients.role.contact',
),
})
.click()
const voiding = page.getByRole('dialog', {
name: dict['relations.void.title'],
})
await expect(voiding).toContainText(dict['relations.void.body'])
await expectAccessible(page, 'the void confirmation')
await voiding
.getByRole('button', { name: dict['relations.void.confirm'] })
.click()
await expect(voiding).toBeHidden()
await expect(page.getByText(dict['relations.void.done'])).toBeVisible()
await expect(card.getByRole('link', { name: wrong })).toHaveCount(0)
await expect(card.locator(':focus')).toHaveCount(1)
expect(
await count(
`public.animal_client_relations r join public.clients c on c.id = r.client_id
where c.display_name = ${literal(wrong)} and r.voided_at is not null`,
),
).toBe('1')
await card
.getByRole('button', {
name: actionName(
dict,
'relations.end.action',
former,
'clients.role.owner',
),
})
.click()
const ending = page.getByRole('dialog', {
name: dict['relations.end.title'],
})
await expect(ending).toContainText(dict['relations.end.body'])
await ending.getByLabel(dict['relations.end.ended_on']).fill('2017-01-01')
await ending
.getByRole('button', { name: dict['relations.end.confirm'] })
.click()
await expect(
ending.getByText(dict['relations.error.end_before_start']),
).toBeVisible()
await expect(
ending.getByLabel(dict['relations.end.ended_on']),
).toBeFocused()
await ending.getByLabel(dict['relations.end.ended_on']).fill('2025-09-30')
await expectAccessible(page, 'the end confirmation')
await ending
.getByRole('button', { name: dict['relations.end.confirm'] })
.click()
await expect(ending).toBeHidden()
await expect(page.getByText(dict['relations.end.done'])).toBeVisible()
await expect(card.locator(':focus')).toHaveCount(1)
const history = card.locator(
'section[aria-labelledby="animal-relations-former"]',
)
await expect(history).toContainText(dict['clients.role.former_owner'])
await expect(history).toContainText(
dict['relations.until'].replace(
'{date}',
formatDate('2025-09-30', locale),
),
)
await expect(current.getByRole('link', { name: former })).toHaveCount(0)
await expectAccessible(page, 'an animal with its history')
await expectNoHorizontalOverflow(page, 'an animal with its history')
await history.getByRole('link', { name: former }).click()
await expect(heading(page, former)).toBeFocused()
const formerGroup = page.locator(
'section[aria-labelledby="client-animals-former"]',
)
await expect(formerGroup.getByRole('link', { name: mare })).toBeVisible()
await expect(formerGroup).toContainText(dict['clients.role.former_owner'])
})
test('two accounts and a change of session: nothing of A reaches B', async ({
page,
requests,
}, info) => {
const secret = `Animal Secret ${tagOf()}`
const a = await createAccount(locale, false)
const b = await createAccount(locale, false)
requests.forbid(
a.email,
a.password,
b.email,
b.password,
b.displayName,
secret,
)
const id = await seedAnimal(a, secret)
await signIn(page, b, dict)
await openAnimals(page, dict, info)
await expect(page.getByText(dict['animals.list.empty'])).toBeVisible()
await page
.getByRole('searchbox', { name: dict['animals.list.search_label'] })
.fill(secret)
await expect(
page.getByText(dict['animals.list.no_results']),
).toBeVisible()
for (const path of [
`/app/animals/${id}`,
`/app/animals/${id}/edit`,
`/app/animals/${randomUUID()}`,
'/app/animals/not-an-id',
]) {
await page.goto(path)
await expect(
heading(page, dict['animals.not_found.title']),
).toBeFocused()
await expect(page.getByText(secret)).toHaveCount(0)
}
await expectAccessible(page, 'the animal not found screen')
await signOut(page, dict, info)
await signIn(page, a, dict)
await openAnimals(page, dict, info)
await expect(listRows(page, dict)).toHaveCount(1)
await expect(listRows(page, dict).first()).toContainText(secret)
await signOut(page, dict, info)
await page.goto(`/app/animals/${id}`)
await expect(page).toHaveURL(/\/login/)
await expect(page.getByText(secret)).toHaveCount(0)
await signIn(page, b, dict)
await openAnimals(page, dict, info)
await expect(page.getByText(dict['animals.list.empty'])).toBeVisible()
await expect(page.getByText(secret)).toHaveCount(0)
})
test('keyboard only: create an animal, a refused submit focuses its field', async ({
page,
requests,
}, info) => {
const name = `Clavier Fictif ${tagOf()}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
name,
)
await signIn(page, account, dict)
await openAnimals(page, dict, info)
await page.keyboard.press('Tab')
await expect(
page.getByRole('link', { name: dict['animals.list.new'] }),
).toBeFocused()
await page.keyboard.press('Enter')
await expect(
heading(page, dict['animals.form.create_title']),
).toBeFocused()
await page.keyboard.press('Tab')
const field = page.getByLabel(dict['animals.form.name'])
await expect(field).toBeFocused()
await page.keyboard.press('Enter')
await expect(page.getByText(dict['animals.error.required'])).toBeVisible()
await expect(field).toBeFocused()
await expect(field).toHaveAttribute('aria-invalid', 'true')
await expectAccessible(page, 'the animal form with errors')
await page.keyboard.type(name)
await page.keyboard.press('Tab')
const species = page.getByRole('combobox', {
name: dict['animals.form.species'],
})
await expect(species).toBeFocused()
// The select's type-ahead: the first letters of the localized name.
await page.keyboard.type(locale === 'fr' ? 'Chien' : 'Dog')
await expect(species).toHaveValue('canine')
await page.keyboard.press('Tab')
const male = page.getByRole('radio', {
name: dict['animals.sex.male'],
exact: true,
})
await expect(male).toBeFocused()
await page.keyboard.press('Space')
await expect(male).toBeChecked()
await page.keyboard.press('Shift+Tab')
await page.keyboard.press('Shift+Tab')
await expect(field).toBeFocused()
await page.keyboard.press('Enter')
await expect(heading(page, name)).toBeFocused()
})
test('a concurrent edit: the saved values beside the typed ones, then a knowing save', async ({
page,
requests,
}) => {
const name = `Révision Fictive ${tagOf()}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
name,
)
const id = await seedAnimal(account, name)
await signIn(page, account, dict)
await page.goto(`/app/animals/${id}/edit`)
const breed = page.getByLabel(dict['animals.form.breed'])
await expect(page.getByLabel(dict['animals.form.name'])).toHaveValue(name)
await breed.fill('Selle Français')
await sql(
`update public.animals set breed = 'Pur-sang', revision = revision + 1 where id = ${literal(id)}`,
)
const save = page.getByRole('button', {
name: dict['animals.form.submit_update'],
exact: true,
})
await save.click()
await expect(
page.getByText(dict['animals.form.conflict_title']),
).toBeVisible()
await expect(breed).toHaveValue('Selle Français')
await expect(
page.getByText(
dict['animals.form.stored_value'].replace('{value}', 'Pur-sang'),
),
).toBeVisible()
await expectAccessible(page, 'the animal conflict')
await save.click()
await expect(page.getByText(dict['animals.detail.updated'])).toBeVisible()
expect(
await sql(
`select breed || '/' || revision from public.animals where id = ${literal(id)}`,
),
).toBe('Selle Français/3')
})
test('a lost answer: the retry sends the same request id, one animal and one relation exist', async ({
page,
requests,
}) => {
const tag = tagOf()
const client = `Reprise Cliente ${tag}`
const name = `Reprise Animal ${tag}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
client,
name,
)
const clientId = await seedClient(account, client)
await signIn(page, account, dict)
const sent: string[] = []
await page.route('**/rest/v1/rpc/create_animal', async (route) => {
sent.push(
JSON.parse(route.request().postData() ?? '{}').create_request_id,
)
if (sent.length > 1) return route.fallback()
// The server creates the animal and its relation; the answer never reaches the page.
await route.fetch({ url: sandboxUrl(route.request().url()) ?? '' })
await route.abort('failed')
})
await page.goto(`/app/clients/${clientId}`)
await page
.getByRole('link', { name: dict['clients.animals.add_first'] })
.click()
await page.getByLabel(dict['animals.form.name']).fill(name)
await page
.getByRole('combobox', { name: dict['animals.form.species'] })
.selectOption('feline')
await page
.getByRole('radio', { name: dict['animals.sex.male'], exact: true })
.check()
await page
.getByRole('radio', { name: dict['clients.role.owner'], exact: true })
.check()
const submit = page.getByRole('button', {
name: dict['animals.form.submit_create'],
})
await submit.click()
await expect(
page.getByText(dict['animals.failure.network']),
).toBeVisible()
const made = `public.animals a join public.animal_client_relations r on r.animal_id = a.id
where a.name = ${literal(name)} and r.client_id = ${literal(clientId)}`
expect(await count(made)).toBe('1')
await submit.click()
await expect(heading(page, client)).toBeVisible()
expect(sent).toHaveLength(2)
expect(sent[0]).toBe(sent[1])
expect(await count(made)).toBe('1')
expect(await count(`public.animals where name = ${literal(name)}`)).toBe(
'1',
)
})
test('failures: a list retries, a failed relation write stays in its dialog, an archived client is refused', async ({
page,
requests,
}, info) => {
const tag = tagOf()
const name = `Réseau Animal ${tag}`
const owner = `Réseau Client ${tag}`
const other = `Archivée Ensuite ${tag}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
name,
owner,
other,
tag,
)
const animalId = await seedAnimal(account, name)
const ownerId = await seedClient(account, owner)
const otherId = await seedClient(account, other)
await seedRelation(account, animalId, ownerId, 'owner')
await signIn(page, account, dict)
let failing = true
await page.route('**/rest/v1/rpc/search_animals', (route) =>
failing ? route.abort('failed') : route.fallback(),
)
await openAnimals(page, dict, info)
await expect(
page.getByText(dict['animals.failure.network']),
).toBeVisible()
failing = false
await page.getByRole('button', { name: dict['common.retry'] }).click()
await expect(listRows(page, dict)).toHaveCount(1)
await listRows(page, dict).first().getByRole('link').click()
await expect(heading(page, name)).toBeFocused()
let endFailing = true
await page.route('**/rest/v1/rpc/end_animal_client_relation', (route) =>
endFailing ? route.abort('failed') : route.fallback(),
)
const card = relationsCard(page)
await card
.getByRole('button', {
name: actionName(
dict,
'relations.end.action',
owner,
'clients.role.owner',
),
})
.click()
const ending = page.getByRole('dialog', {
name: dict['relations.end.title'],
})
await ending.getByLabel(dict['relations.end.ended_on']).fill('2025-01-15')
await ending
.getByRole('button', { name: dict['relations.end.confirm'] })
.click()
await expect(
ending.getByText(dict['relations.failure.network']),
).toBeVisible()
await expect(
ending.getByLabel(dict['relations.end.ended_on']),
).toHaveValue('2025-01-15')
endFailing = false
await ending
.getByRole('button', { name: dict['relations.end.confirm'] })
.click()
await expect(ending).toBeHidden()
await expect(page.getByText(dict['relations.end.done'])).toBeVisible()
await card
.getByRole('button', { name: dict['relations.add_client'] })
.click()
const panel = page.getByRole('form', {
name: dict['relations.panel.title_client'],
})
await pick(panel, dict['relations.picker.client_label'], other)
await panel
.getByRole('radio', { name: dict['clients.role.contact'], exact: true })
.check()
await sql(
`update public.clients set archived_at = now() where id = ${literal(otherId)}`,
)
await panel
.getByRole('button', { name: dict['relations.panel.save_client'] })
.click()
await expect(
panel.getByText(dict['relations.failure.archived']),
).toBeVisible()
await expect(
panel.getByRole('radio', {
name: dict['clients.role.contact'],
exact: true,
}),
).toBeChecked()
})
test('the animal pages follow a change of language', async ({
page,
requests,
}, info) => {
const tag = tagOf()
const name = `Animal Bilingue ${tag}`
const owner = `Client Bilingue ${tag}`
const account = await createAccount(locale, false)
requests.forbid(
account.email,
account.password,
account.displayName,
name,
owner,
)
const animalId = await seedAnimal(account, name, 'canine', 'male')
await seedRelation(
account,
animalId,
await seedClient(account, owner),
'owner',
)
await signIn(page, account, dict)
await openAnimals(page, dict, info)
const other = locale === 'fr' ? en : fr
await page
.getByRole('button', {
name: dict[
locale === 'fr' ? 'lang.switch_to_en' : 'lang.switch_to_fr'
],
})
.click()
await expect(
page.getByRole('link', { name: other['animals.list.new'] }),
).toBeVisible()
await expect(
page.getByRole('combobox', {
name: other['animals.list.species_filter'],
}),
).toBeVisible()
await expect(listRows(page, other).first()).toContainText(
other['animals.sex.male'],
)
await expect(listRows(page, other).first()).toContainText(
other['animals.list.owner'].replace('{names}', owner),
)
await expectAccessible(page, 'the animal list after a change of language')
await listRows(page, other).first().getByRole('link').click()
await expect(relationsCard(page)).toContainText(other['relations.title'])
await expect(relationsCard(page)).toContainText(
other['clients.role.owner'],
)
})
})
}