Files
faunosteo/apps/app/tests/unit/routes.animals.test.tsx
bchanot 930499cd25 feat(app): animal screens, relation panels, animals on the client page
Routes /app/animals, new, :animalId, edit under one workspace gate; list with
species filter; form (D-R7, U3 birth, no default sex or role, optional first
client); page with current and former relations, end, dates, void; client page
links its animals, adds one pre-associated, links an existing one. Card now
passes aria-labelledby, which it silently dropped.
2026-10-26 17:11:28 +01:00

1199 lines
39 KiB
TypeScript

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 {
MemoryRouter,
Route,
Routes,
useLocation,
type InitialEntry,
} from 'react-router-dom'
import {
createFakeSupabase,
fakeProfile,
fakeUser,
type FakeSupabase,
} from '../helpers/fakeSupabase'
const mocks = vi.hoisted(() => ({ fake: null as unknown }))
vi.mock('@/lib/supabase', () => ({
getSupabaseClient: () => (mocks.fake as FakeSupabase | null)?.client ?? null,
isSupabaseConfigured: () => mocks.fake !== null,
}))
import AppLayout from '@/components/shell/AppLayout'
import RequireWorkspace from '@/app/guards/RequireWorkspace'
import ClientDetailRoute from '@/app/routes/app/clients/ClientDetailRoute'
import AnimalsListRoute from '@/app/routes/app/animals/AnimalsListRoute'
import AnimalCreateRoute from '@/app/routes/app/animals/AnimalCreateRoute'
import AnimalDetailRoute from '@/app/routes/app/animals/AnimalDetailRoute'
import AnimalEditRoute from '@/app/routes/app/animals/AnimalEditRoute'
import { SEARCH_DELAY_MS } from '@/clients/useClientList'
import { useAuthStore } from '@/state/authStore'
import { useLocaleStore } from '@/state/localeStore'
import { fr } from '@/i18n/fr'
/**
* The animal screens and the client page's animals on a fake client: states,
* the calls they make and what they keep. The RPC shapes are proven in
* packages/supabase (unit and real PostgREST); the journeys run in Chromium.
*/
const WS = '11111111-1111-4111-8111-111111111111'
const AID = '22222222-2222-4222-8222-222222222222'
const CID = '33333333-3333-4333-8333-333333333333'
const R1 = '44444444-4444-4444-8444-444444444441'
const R2 = '44444444-4444-4444-8444-444444444442'
const R3 = '44444444-4444-4444-8444-444444444443'
const R4 = '44444444-4444-4444-8444-444444444444'
let fake: FakeSupabase
const SPECIES = [
{
id: 'equine',
name_fr: 'Cheval',
name_en: 'Horse',
sort_order: 10,
active: true,
},
{
id: 'canine',
name_fr: 'Chien',
name_en: 'Dog',
sort_order: 30,
active: true,
},
{
id: 'other',
name_fr: 'Autre',
name_en: 'Other',
sort_order: 1000,
active: true,
},
]
function listRow(i: number, patch: Record<string, unknown> = {}) {
return {
id: `00000000-0000-4000-8000-${String(i).padStart(12, '0')}`,
name: `Animal ${String(i).padStart(2, '0')}`,
species_id: 'equine',
species_detail: null,
sex: 'female',
breed: null,
birth_year: null,
archived_at: null,
name_key: `animal ${String(i).padStart(2, '0')}`,
current_owners: [],
current_owner_count: 0,
...patch,
}
}
function animalRow(patch: Record<string, unknown> = {}) {
return {
id: AID,
name: 'Tornado',
species_id: 'equine',
species_detail: null,
sex: 'female',
breed: 'Pur-sang',
birth_year: 2015,
birth_date: '2015-04-12',
revision: 1,
archived_at: null,
created_at: '2026-10-26T10:00:00Z',
updated_at: '2026-10-26T10:00:00Z',
...patch,
}
}
function clientRow(patch: Record<string, unknown> = {}) {
return {
id: CID,
kind: 'person',
display_name: 'Marie Dupont',
email: null,
phone: null,
address_line1: null,
address_line2: null,
postal_code: null,
city: 'Lyon',
country: null,
revision: 1,
archived_at: null,
created_at: '2026-10-26T10:00:00Z',
updated_at: '2026-10-26T10:00:00Z',
...patch,
}
}
function relationRow(
id: string,
name: string,
patch: Record<string, unknown> = {},
) {
return {
id,
animal_id: AID,
relation_role: 'owner',
started_on: null,
ended_on: null,
ended_at: null,
voided_at: null,
revision: 1,
created_at: '2026-10-26T10:00:00Z',
client: {
id: `55555555-5555-4555-8555-55555555555${id.slice(-1)}`,
kind: 'person',
display_name: name,
phone: null,
email: null,
archived_at: null,
},
...patch,
}
}
const page = () => within(screen.getByRole('main'))
const rpcArgs = (name: string) =>
fake.rpcCalls
.filter(([n]) => n === name)
.map(([, a]) => a as Record<string, unknown>)
function Where() {
return <span data-testid="where">{useLocation().pathname}</span>
}
function mount(entry: InitialEntry) {
useAuthStore.setState({
status: 'signed_in',
user: fakeUser(),
profile: fakeProfile(),
workspace: { status: 'ready', id: WS },
})
return render(
<MemoryRouter initialEntries={[entry]}>
<Routes>
<Route path="/app" element={<AppLayout />}>
<Route index element={<p>dashboard</p>} />
<Route element={<RequireWorkspace />}>
<Route path="clients">
<Route index element={<p>clients</p>} />
<Route path=":clientId" element={<ClientDetailRoute />} />
</Route>
<Route path="animals">
<Route index element={<AnimalsListRoute />} />
<Route path="new" element={<AnimalCreateRoute />} />
<Route path=":animalId" element={<AnimalDetailRoute />} />
<Route path=":animalId/edit" element={<AnimalEditRoute />} />
</Route>
</Route>
</Route>
</Routes>
<Where />
</MemoryRouter>,
)
}
/** Holds the next call of `name` until released (the fake answers `result`). */
function holdRpc(name: string, result: { data?: unknown; error?: unknown }) {
let release: () => void = () => undefined
const pending = new Promise<void>((resolve) => (release = resolve))
const client = fake.client as unknown as {
rpc: (n: string, a: unknown) => Promise<unknown>
}
const rpc = client.rpc.bind(client)
client.rpc = async (n, args) => {
if (n !== name) return rpc(n, args)
fake.rpcCalls.push([n, args])
await pending
return { data: result.data ?? null, error: result.error ?? null }
}
return () => act(async () => release())
}
const label = (key: string) =>
new RegExp(fr[key].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
async function fillIdentity(name = 'Tornado') {
await userEvent.type(screen.getByLabelText(label('animals.form.name')), name)
await userEvent.selectOptions(
screen.getByRole('combobox', { name: label('animals.form.species') }),
'equine',
)
await userEvent.click(
screen.getByRole('radio', { name: fr['animals.sex.female'] }),
)
}
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
fake = createFakeSupabase()
fake.tables.species = SPECIES.map((s) => ({ ...s }))
fake.tables.animals = []
fake.tables.clients = []
fake.tables.animal_client_relations = []
fake.rpcResults.search_animals = { data: [] }
fake.rpcResults.search_clients = { data: [] }
fake.rpcResults.list_client_animals = { data: [] }
mocks.fake = fake
})
afterEach(() => {
cleanup()
vi.useRealTimers()
})
describe('animal list', () => {
it('lists the first page with owners or « Propriétaire non renseigné », then « Afficher plus »', async () => {
fake.rpcResults.search_animals = {
data: [
listRow(1, {
current_owners: [
{ client_id: CID, display_name: 'Marie Dupont', archived: false },
],
current_owner_count: 1,
}),
...Array.from({ length: 25 }, (_, i) => listRow(i + 2)),
],
}
mount('/app/animals')
expect(page().getByRole('status')).toHaveTextContent(
fr['animals.list.loading'],
)
expect(await screen.findByText('Animal 01')).toBeInTheDocument()
expect(
page().getByRole('heading', { level: 1, name: fr['animals.list.title'] }),
).toHaveFocus()
expect(screen.getByText('Propriétaire : Marie Dupont')).toBeInTheDocument()
expect(screen.getAllByText(fr['animals.no_owner']).length).toBeGreaterThan(
0,
)
const results = screen.getByRole('list', {
name: fr['animals.list.results_label'],
})
expect(within(results).getAllByRole('listitem')).toHaveLength(25)
expect(rpcArgs('search_animals')[0]).toMatchObject({
workspace_id: WS,
query: '',
archived: false,
page_size: 26,
species_filter: undefined,
})
fake.rpcResults.search_animals = { data: [listRow(26), listRow(27)] }
await userEvent.click(
screen.getByRole('button', { name: fr['animals.list.more'] }),
)
expect(await screen.findByText('Animal 27')).toBeInTheDocument()
expect(rpcArgs('search_animals').at(-1)).toMatchObject({
after_name_key: 'animal 25',
after_id: listRow(25).id,
})
expect(
screen.queryByRole('button', { name: fr['animals.list.more'] }),
).toBeNull()
})
it('says it is empty', async () => {
mount('/app/animals')
expect(
await screen.findByText(fr['animals.list.empty']),
).toBeInTheDocument()
expect(screen.getByText(fr['animals.list.empty_hint'])).toBeInTheDocument()
})
it('filters by species and by archive, in the RPC body', async () => {
mount('/app/animals')
await screen.findByText(fr['animals.list.empty'])
const filter = screen.getByRole('combobox', {
name: fr['animals.list.species_filter'],
})
await waitFor(() =>
expect(
within(filter).getByRole('option', { name: 'Chien' }),
).toBeInTheDocument(),
)
await userEvent.selectOptions(filter, 'canine')
await waitFor(() =>
expect(rpcArgs('search_animals').at(-1)?.species_filter).toBe('canine'),
)
expect(
await screen.findByText(fr['animals.list.no_results']),
).toBeInTheDocument()
fake.rpcResults.search_animals = {
data: [listRow(1, { archived_at: '2026-10-26T10:00:00Z' })],
}
await userEvent.click(
screen.getByRole('switch', { name: fr['animals.list.archived_toggle'] }),
)
expect(
await screen.findByText(fr['animals.archived_badge']),
).toBeInTheDocument()
expect(rpcArgs('search_animals').at(-1)).toMatchObject({
archived: true,
species_filter: 'canine',
})
})
it('waits for a pause in typing, then sends the term in the body once', async () => {
vi.useFakeTimers({ shouldAdvanceTime: true })
mount('/app/animals')
await screen.findByText(fr['animals.list.empty'])
const before = rpcArgs('search_animals').length
const box = screen.getByRole('searchbox', {
name: label('animals.list.search_label'),
})
for (const value of ['t', 'to', 'tor'])
fireEvent.change(box, { target: { value } })
await act(() => vi.advanceTimersByTimeAsync(SEARCH_DELAY_MS + 10))
await waitFor(() =>
expect(rpcArgs('search_animals').length).toBe(before + 1),
)
expect(rpcArgs('search_animals').at(-1)?.query).toBe('tor')
})
it('names a failure and retries', async () => {
fake.rpcResults.search_animals = {
error: { code: 'P0001', message: 'rate_limited' },
}
mount('/app/animals')
expect(
await screen.findByText(fr['animals.failure.rate_limited']),
).toBeInTheDocument()
fake.rpcResults.search_animals = { data: [listRow(1)] }
await userEvent.click(
screen.getByRole('button', { name: fr['common.retry'] }),
)
expect(await screen.findByText('Animal 01')).toBeInTheDocument()
})
})
describe('animal creation', () => {
it('refuses an empty form, focuses the name; no sex is preselected', async () => {
mount('/app/animals/new')
for (const sex of ['male', 'female', 'unknown'])
expect(
screen.getByRole('radio', { name: fr[`animals.sex.${sex}`] }),
).not.toBeChecked()
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
expect(screen.getByLabelText(label('animals.form.name'))).toHaveFocus()
expect(screen.getByText(fr['animals.error.required'])).toBeInTheDocument()
expect(screen.getByText(fr['animals.error.species'])).toBeInTheDocument()
expect(screen.getByText(fr['animals.error.sex'])).toBeInTheDocument()
expect(rpcArgs('create_animal')).toEqual([])
})
it('« Autre » asks for its detail', async () => {
mount('/app/animals/new')
expect(
screen.queryByLabelText(label('animals.form.species_detail')),
).toBeNull()
const species = screen.getByRole('combobox', {
name: label('animals.form.species'),
})
await waitFor(() =>
expect(
within(species).getByRole('option', { name: 'Autre' }),
).toBeInTheDocument(),
)
await userEvent.selectOptions(species, 'other')
expect(
screen.getByLabelText(label('animals.form.species_detail')),
).toBeInTheDocument()
})
it('a full birth date fills and locks the year; clearing it unlocks', async () => {
mount('/app/animals/new')
const year = screen.getByLabelText(label('animals.form.birth_year'))
const date = screen.getByLabelText(label('animals.form.birth_date'))
fireEvent.change(date, { target: { value: '2015-04-12' } })
expect(year).toHaveValue('2015')
expect(year).toHaveAttribute('readonly')
fireEvent.change(date, { target: { value: '' } })
expect(year).toHaveValue('2015')
expect(year).not.toHaveAttribute('readonly')
})
it('sends the same request id after a lost answer, then opens the animal', async () => {
fake.rpcResults.create_animal = {
error: { code: '', message: 'TypeError: fetch failed' },
}
mount('/app/animals/new')
await screen.findByRole('option', { name: 'Cheval' })
await fillIdentity()
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
expect(
await screen.findByText(fr['animals.failure.unavailable']),
).toBeInTheDocument()
fake.rpcResults.create_animal = {
data: { id: AID, revision: 1, relation_id: null },
}
fake.tables.animals = [animalRow()]
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
await waitFor(() =>
expect(screen.getByTestId('where')).toHaveTextContent(
`/app/animals/${AID}`,
),
)
const [first, second] = rpcArgs('create_animal')
expect(first.create_request_id).toBe(second.create_request_id)
expect(first).toMatchObject({
workspace_id: WS,
name: 'Tornado',
species_id: 'equine',
sex: 'female',
})
expect(first.client_id).toBeUndefined()
expect(
await screen.findByText(fr['animals.detail.created']),
).toBeInTheDocument()
})
it('a new form is a new intent: another request id', async () => {
fake.rpcResults.create_animal = {
error: { code: 'P0001', message: 'rate_limited' },
}
const first = mount('/app/animals/new')
await screen.findByRole('option', { name: 'Cheval' })
await fillIdentity()
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
await screen.findByText(fr['animals.failure.rate_limited'])
first.unmount()
mount('/app/animals/new')
await screen.findByRole('option', { name: 'Cheval' })
await fillIdentity()
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
await screen.findByText(fr['animals.failure.rate_limited'])
const ids = rpcArgs('create_animal').map((a) => a.create_request_id)
expect(ids[0]).not.toBe(ids[1])
})
})
describe('animal creation from a client page', () => {
const fromClient = (clientId: unknown = CID) => ({
pathname: '/app/animals/new',
state: { clientId },
})
it('pre-associates the client with no role; refuses a save without a role; one create_animal with the relation', async () => {
fake.tables.clients = [clientRow()]
mount(fromClient())
expect(await screen.findByText('Marie Dupont')).toBeInTheDocument()
expect(
screen.getByText(fr['relations.panel.client_chosen'], { exact: false }),
).toBeInTheDocument()
for (const role of ['owner', 'keeper', 'contact'])
expect(
screen.getByRole('radio', { name: fr[`clients.role.${role}`] }),
).not.toBeChecked()
await screen.findByRole('option', { name: 'Cheval' })
await fillIdentity()
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
expect(screen.getByText(fr['animals.error.role'])).toBeInTheDocument()
expect(rpcArgs('create_animal')).toEqual([])
await userEvent.click(
screen.getByRole('radio', { name: fr['clients.role.owner'] }),
)
fake.rpcResults.create_animal = {
data: { id: AID, revision: 1, relation_id: R1 },
}
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
await waitFor(() =>
expect(screen.getByTestId('where')).toHaveTextContent(
`/app/clients/${CID}`,
),
)
expect(rpcArgs('create_animal')).toHaveLength(1)
expect(rpcArgs('create_animal')[0]).toMatchObject({
client_id: CID,
relation_role: 'owner',
})
expect(rpcArgs('create_animal')[0].started_on).toBeUndefined()
expect(rpcArgs('create_animal_client_relation')).toEqual([])
expect(
await screen.findByText(fr['clients.detail.animal_added']),
).toBeInTheDocument()
})
it('removing the client sends none and opens the animal', async () => {
fake.tables.clients = [clientRow()]
mount(fromClient())
await userEvent.click(
await screen.findByRole('button', {
name: fr['animals.form.client_remove'],
}),
)
expect(
screen.getByRole('searchbox', {
name: label('relations.picker.client_label'),
}),
).toHaveFocus()
await screen.findByRole('option', { name: 'Cheval' })
await fillIdentity()
fake.rpcResults.create_animal = {
data: { id: AID, revision: 1, relation_id: null },
}
fake.tables.animals = [animalRow()]
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_create'] }),
)
await waitFor(() =>
expect(screen.getByTestId('where')).toHaveTextContent(
`/app/animals/${AID}`,
),
)
expect(rpcArgs('create_animal')[0].client_id).toBeUndefined()
expect(rpcArgs('create_animal')[0].relation_role).toBeUndefined()
})
it.each([
['archived', [clientRow({ archived_at: '2026-10-26T11:00:00Z' })]],
['unknown', []],
])(
'an %s origin client is not pre-associated, and the page says so',
async (_, rows) => {
fake.tables.clients = rows
mount(fromClient())
expect(
await screen.findByText(fr['animals.form.origin_unavailable']),
).toBeInTheDocument()
expect(
screen.queryByText(fr['relations.panel.client_chosen'], {
exact: false,
}),
).toBeNull()
},
)
it('a malformed state value reads nothing', async () => {
const from = vi.spyOn(
fake.client as unknown as { from: (t: string) => unknown },
'from',
)
mount(fromClient('not-an-id'))
await screen.findByRole('option', { name: 'Cheval' })
expect(from.mock.calls.map(([t]) => t)).not.toContain('clients')
expect(screen.queryByText(fr['animals.form.origin_unavailable'])).toBeNull()
})
})
describe('animal edit', () => {
it('on conflict shows the stored value beside the typed one and keeps it', async () => {
fake.tables.animals = [animalRow()]
mount(`/app/animals/${AID}/edit`)
const name = await screen.findByLabelText(label('animals.form.name'))
expect(name).toHaveValue('Tornado')
await userEvent.clear(name)
await userEvent.type(name, 'Typhon')
fake.tables.animals = [animalRow({ name: 'Ouragan', revision: 2 })]
fake.rpcResults.update_animal = {
error: { code: 'P0001', message: 'conflict' },
}
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_update'] }),
)
expect(
await screen.findByText(fr['animals.form.conflict_title']),
).toBeInTheDocument()
expect(name).toHaveValue('Typhon')
expect(
screen.getByText(
fr['animals.form.stored_value'].replace('{value}', 'Ouragan'),
),
).toBeInTheDocument()
fake.rpcResults.update_animal = { data: { revision: 3 } }
await userEvent.click(
screen.getByRole('button', { name: fr['animals.form.submit_update'] }),
)
await waitFor(() =>
expect(screen.getByTestId('where')).toHaveTextContent(
`/app/animals/${AID}`,
),
)
expect(rpcArgs('update_animal').map((a) => a.expected_revision)).toEqual([
1, 2,
])
expect(rpcArgs('update_animal')[1]).toMatchObject({
name: 'Typhon',
birth_year: '2015',
birth_date: '2015-04-12',
species_detail: null,
})
})
it('an archived animal has no form', async () => {
fake.tables.animals = [animalRow({ archived_at: '2026-10-26T11:00:00Z' })]
mount(`/app/animals/${AID}/edit`)
expect(
await screen.findByText(fr['animals.detail.archived_notice']),
).toBeInTheDocument()
expect(
screen.queryByRole('button', { name: fr['animals.form.submit_update'] }),
).toBeNull()
})
})
describe('animal page', () => {
it('shows the identity with the birth precision', async () => {
fake.tables.animals = [animalRow()]
mount(`/app/animals/${AID}`)
expect(
await page().findByRole('heading', { level: 1, name: 'Tornado' }),
).toHaveFocus()
expect(await screen.findByText('Cheval')).toBeInTheDocument()
expect(screen.getByText('Femelle')).toBeInTheDocument()
expect(screen.getByText('Pur-sang')).toBeInTheDocument()
expect(
screen.getByText(/^Le 12 avril 2015 \(\d+ ans\)$/),
).toBeInTheDocument()
expect(
screen.getByText(fr['animals.detail.status_active']),
).toBeInTheDocument()
})
it.each([
[{ birth_date: null, birth_year: 2015 }, /^En 2015 \(environ \d+ ans\)$/],
[
{ birth_date: null, birth_year: null },
new RegExp(`^${fr['animals.detail.birth_unknown']}$`),
],
])('birth %o', async (patch, text) => {
fake.tables.animals = [animalRow(patch)]
mount(`/app/animals/${AID}`)
expect(await screen.findByText(text)).toBeInTheDocument()
})
it('shows the same « introuvable » for an unknown id and a malformed one', async () => {
mount(`/app/animals/${AID}`)
expect(
await screen.findByRole('heading', {
name: fr['animals.not_found.title'],
}),
).toHaveFocus()
cleanup()
mount('/app/animals/not-an-id')
expect(
await screen.findByRole('heading', {
name: fr['animals.not_found.title'],
}),
).toHaveFocus()
})
it('archives after a confirmation that refuses to close while the request runs', async () => {
fake.tables.animals = [animalRow()]
const release = holdRpc('set_animal_archived', { data: { revision: 2 } })
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', { name: fr['animals.detail.archive'] }),
)
const dialog = await screen.findByRole('dialog', {
name: fr['animals.archive.title'],
})
await userEvent.click(
within(dialog).getByRole('button', {
name: fr['animals.archive.confirm'],
}),
)
await userEvent.click(
within(dialog).getByRole('button', { name: fr['common.cancel'] }),
)
expect(dialog).toBeInTheDocument()
fake.tables.animals = [
animalRow({ archived_at: '2026-10-26T11:00:00Z', revision: 2 }),
]
await release()
expect(
await screen.findByText(fr['animals.detail.archived']),
).toBeInTheDocument()
await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
expect(rpcArgs('set_animal_archived')).toEqual([
{ animal_id: AID, archived: true },
])
})
it('an archived animal is read-only, relations included, and can be restored', async () => {
fake.tables.animals = [
animalRow({ archived_at: '2026-10-26T11:00:00Z', revision: 2 }),
]
fake.tables.animal_client_relations = [relationRow(R1, 'Marie Dupont')]
mount(`/app/animals/${AID}`)
expect(
await screen.findByText(fr['animals.detail.archived_notice']),
).toBeInTheDocument()
expect(
await screen.findByRole('link', { name: 'Marie Dupont' }),
).toBeInTheDocument()
expect(screen.queryByRole('button', { name: /Terminer/ })).toBeNull()
expect(
screen.queryByRole('button', { name: fr['relations.add_client'] }),
).toBeNull()
expect(
screen.queryByRole('link', { name: fr['animals.detail.edit'] }),
).toBeNull()
fake.rpcResults.set_animal_archived = { data: { revision: 3 } }
fake.tables.animals = [animalRow({ revision: 3 })]
await userEvent.click(
screen.getByRole('button', { name: fr['animals.detail.restore'] }),
)
expect(
await screen.findByText(fr['animals.detail.restored']),
).toBeInTheDocument()
expect(rpcArgs('set_animal_archived')).toEqual([
{ animal_id: AID, archived: false },
])
expect(
await screen.findByRole('button', { name: fr['relations.add_client'] }),
).toBeInTheDocument()
})
})
describe('animal relations', () => {
function seed() {
fake.tables.animals = [animalRow()]
fake.tables.animal_client_relations = [
relationRow(R1, 'Marie Dupont', { started_on: '2020-03-01' }),
relationRow(R2, 'Écurie du Lac', { relation_role: 'keeper' }),
relationRow(R3, 'Jean Martin', {
ended_at: '2024-01-01T00:00:00Z',
ended_on: '2023-12-31',
}),
relationRow(R4, 'Fantôme Erroné', { voided_at: '2026-01-01T00:00:00Z' }),
]
}
it('groups current and former relations; a voided one is never shown', async () => {
seed()
mount(`/app/animals/${AID}`)
expect(
await screen.findByRole('link', { name: 'Marie Dupont' }),
).toHaveAttribute(
'href',
`/app/clients/55555555-5555-4555-8555-555555555551`,
)
expect(
screen.getByRole('heading', { name: fr['relations.current'] }),
).toBeInTheDocument()
expect(
screen.getByRole('heading', { name: fr['relations.former'] }),
).toBeInTheDocument()
expect(
screen.getByText(/Ancien propriétaire · jusqu'au 31 décembre 2023/),
).toBeInTheDocument()
expect(screen.queryByText('Fantôme Erroné')).toBeNull()
expect(screen.queryByText(fr['animals.no_owner'])).toBeNull()
})
it('says « Propriétaire non renseigné » without a current owner', async () => {
fake.tables.animals = [animalRow()]
fake.tables.animal_client_relations = [
relationRow(R2, 'Écurie du Lac', { relation_role: 'keeper' }),
]
mount(`/app/animals/${AID}`)
expect(await screen.findByText(fr['animals.no_owner'])).toBeInTheDocument()
})
it('ends a relation without a date, then with one', async () => {
seed()
fake.rpcResults.end_animal_client_relation = { data: { revision: 2 } }
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', {
name: 'Terminer : Marie Dupont, propriétaire',
}),
)
let dialog = await screen.findByRole('dialog', {
name: fr['relations.end.title'],
})
await userEvent.click(
within(dialog).getByRole('button', { name: fr['relations.end.confirm'] }),
)
expect(
await screen.findByText(fr['relations.end.done']),
).toBeInTheDocument()
await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
expect(rpcArgs('end_animal_client_relation')[0]).toEqual({
relation_id: R1,
expected_revision: 1,
})
await userEvent.click(
screen.getByRole('button', {
name: 'Terminer : Écurie du Lac, détenteur',
}),
)
dialog = await screen.findByRole('dialog', {
name: fr['relations.end.title'],
})
fireEvent.change(
within(dialog).getByLabelText(label('relations.end.ended_on')),
{
target: { value: '2026-01-15' },
},
)
await userEvent.click(
within(dialog).getByRole('button', { name: fr['relations.end.confirm'] }),
)
await waitFor(() =>
expect(rpcArgs('end_animal_client_relation')).toHaveLength(2),
)
expect(rpcArgs('end_animal_client_relation')[1]).toMatchObject({
relation_id: R2,
ended_on: '2026-01-15',
})
})
it('refuses an end before the start, in the dialog', async () => {
seed()
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', {
name: 'Terminer : Marie Dupont, propriétaire',
}),
)
const dialog = await screen.findByRole('dialog', {
name: fr['relations.end.title'],
})
const field = within(dialog).getByLabelText(label('relations.end.ended_on'))
fireEvent.change(field, { target: { value: '2019-01-01' } })
await userEvent.click(
within(dialog).getByRole('button', { name: fr['relations.end.confirm'] }),
)
expect(
within(dialog).getByText(fr['relations.error.end_before_start']),
).toBeInTheDocument()
expect(field).toHaveFocus()
expect(rpcArgs('end_animal_client_relation')).toEqual([])
})
it('a conflict reloads and says the relation changed; a network failure stays in the dialog', async () => {
seed()
fake.rpcResults.end_animal_client_relation = {
error: { code: '', message: 'TypeError: fetch failed' },
}
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', {
name: 'Terminer : Marie Dupont, propriétaire',
}),
)
const dialog = await screen.findByRole('dialog', {
name: fr['relations.end.title'],
})
await userEvent.click(
within(dialog).getByRole('button', { name: fr['relations.end.confirm'] }),
)
expect(
await within(dialog).findByText(fr['relations.failure.unavailable']),
).toBeInTheDocument()
expect(dialog).toBeInTheDocument()
fake.rpcResults.end_animal_client_relation = {
error: { code: 'P0001', message: 'conflict' },
}
fake.tables.animal_client_relations = [
relationRow(R1, 'Marie Dupont', {
revision: 2,
ended_at: '2026-10-26T12:00:00Z',
}),
]
await userEvent.click(
within(dialog).getByRole('button', { name: fr['relations.end.confirm'] }),
)
expect(
await screen.findByText(fr['relations.failure.conflict']),
).toBeInTheDocument()
await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
expect(screen.queryByRole('link', { name: 'Écurie du Lac' })).toBeNull()
})
it('corrects the dates of a former relation', async () => {
seed()
fake.rpcResults.update_animal_client_relation = { data: { revision: 2 } }
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', {
name: 'Corriger les dates : Jean Martin, ancien propriétaire',
}),
)
const dialog = await screen.findByRole('dialog', {
name: fr['relations.dates.title'],
})
fireEvent.change(
within(dialog).getByLabelText(label('relations.dates.started_on')),
{
target: { value: '2018-05-01' },
},
)
await userEvent.click(
within(dialog).getByRole('button', {
name: fr['relations.dates.confirm'],
}),
)
expect(
await screen.findByText(fr['relations.dates.done']),
).toBeInTheDocument()
expect(rpcArgs('update_animal_client_relation')).toEqual([
{
relation_id: R3,
expected_revision: 1,
started_on: '2018-05-01',
ended_on: '2023-12-31',
},
])
})
it('voids a relation entered by mistake after a danger confirmation', async () => {
seed()
fake.rpcResults.void_animal_client_relation = { data: { revision: 2 } }
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', {
name: 'Erreur de saisie : Écurie du Lac, détenteur',
}),
)
const dialog = await screen.findByRole('dialog', {
name: fr['relations.void.title'],
})
expect(dialog).toHaveAccessibleDescription(
expect.stringContaining(fr['relations.void.body']),
)
fake.tables.animal_client_relations =
fake.tables.animal_client_relations.filter((r) => r.id !== R2)
await userEvent.click(
within(dialog).getByRole('button', {
name: fr['relations.void.confirm'],
}),
)
expect(
await screen.findByText(fr['relations.void.done']),
).toBeInTheDocument()
expect(rpcArgs('void_animal_client_relation')).toEqual([
{ relation_id: R2, expected_revision: 1 },
])
await waitFor(() =>
expect(screen.queryByRole('link', { name: 'Écurie du Lac' })).toBeNull(),
)
})
it('the add-client panel needs a choice and a role, phrases a duplicate, reuses its request id', async () => {
fake.tables.animals = [animalRow()]
fake.rpcResults.search_clients = {
data: [
{
id: CID,
kind: 'person',
display_name: 'Marie Dupont',
city: 'Lyon',
phone: null,
email: null,
archived_at: null,
name_key: 'marie dupont',
current_animal_count: 0,
},
],
}
mount(`/app/animals/${AID}`)
await userEvent.click(
await screen.findByRole('button', { name: fr['relations.add_client'] }),
)
expect(
screen.getByRole('heading', { name: fr['relations.panel.title_client'] }),
).toHaveFocus()
await userEvent.click(
screen.getByRole('button', { name: fr['relations.panel.save_client'] }),
)
expect(screen.getByText(fr['animals.error.client'])).toBeInTheDocument()
await userEvent.click(
await screen.findByRole('button', { name: /Marie Dupont/ }),
)
await userEvent.click(
screen.getByRole('button', { name: fr['relations.panel.save_client'] }),
)
expect(screen.getByText(fr['animals.error.role'])).toBeInTheDocument()
expect(rpcArgs('create_animal_client_relation')).toEqual([])
await userEvent.click(
screen.getByRole('radio', { name: fr['clients.role.keeper'] }),
)
fake.rpcResults.create_animal_client_relation = {
error: { code: 'P0001', message: 'duplicate_relation' },
}
await userEvent.click(
screen.getByRole('button', { name: fr['relations.panel.save_client'] }),
)
expect(
await screen.findByText(fr['relations.failure.duplicate_relation']),
).toBeInTheDocument()
fake.rpcResults.create_animal_client_relation = {
data: { id: R1, revision: 1 },
}
fake.tables.animal_client_relations = [
relationRow(R1, 'Marie Dupont', { relation_role: 'keeper' }),
]
await userEvent.click(
screen.getByRole('button', { name: fr['relations.panel.save_client'] }),
)
expect(
await screen.findByText(fr['relations.added_client']),
).toBeInTheDocument()
const calls = rpcArgs('create_animal_client_relation')
expect(calls[0]).toMatchObject({
animal_id: AID,
client_id: CID,
relation_role: 'keeper',
})
expect(calls[0].create_request_id).toBe(calls[1].create_request_id)
await waitFor(() =>
expect(
screen.getByRole('button', { name: fr['relations.add_client'] }),
).toHaveFocus(),
)
})
})
describe('client page animals', () => {
const ANIMAL2 = '66666666-6666-4666-8666-666666666666'
function item(relationId: string, patch: Record<string, unknown> = {}) {
return {
relation_id: relationId,
relation_role: 'owner',
started_on: null,
ended_on: null,
is_current: true,
relation_revision: 1,
animal_id: AID,
animal_name: 'Tornado',
species_id: 'equine',
species_detail: null,
sex: 'female',
breed: null,
birth_year: null,
animal_archived_at: null,
sort_key: '0tornado',
...patch,
}
}
it('shows each animal once with all its roles, linked to its page', async () => {
fake.tables.clients = [clientRow()]
fake.rpcResults.list_client_animals = {
data: [
item(R1),
item(R2, { relation_role: 'keeper' }),
item(R3, {
animal_id: ANIMAL2,
animal_name: 'Éclair',
is_current: false,
sort_key: '1eclair',
}),
],
}
mount(`/app/clients/${CID}`)
const links = await screen.findAllByRole('link', { name: 'Tornado' })
expect(links).toHaveLength(1)
expect(links[0]).toHaveAttribute('href', `/app/animals/${AID}`)
expect(screen.getByText(fr['clients.role.owner'])).toBeInTheDocument()
expect(screen.getByText(fr['clients.role.keeper'])).toBeInTheDocument()
expect(
screen.getByText(fr['clients.role.former_owner']),
).toBeInTheDocument()
expect(
screen.getByRole('link', { name: fr['clients.animals.add'] }),
).toBeInTheDocument()
})
it('offers « Ajouter un premier animal » when there is none, with the client in the navigation state', async () => {
fake.tables.clients = [clientRow()]
mount(`/app/clients/${CID}`)
await userEvent.click(
await screen.findByRole('link', {
name: fr['clients.animals.add_first'],
}),
)
await waitFor(() =>
expect(screen.getByTestId('where')).toHaveTextContent('/app/animals/new'),
)
expect(
await screen.findByText(fr['relations.panel.client_chosen'], {
exact: false,
}),
).toBeInTheDocument()
expect(screen.getByText('Marie Dupont')).toBeInTheDocument()
})
it('links an existing animal with the client id', async () => {
fake.tables.clients = [clientRow()]
fake.rpcResults.search_animals = {
data: [listRow(1, { id: AID, name: 'Tornado' })],
}
mount(`/app/clients/${CID}`)
await userEvent.click(
await screen.findByRole('button', {
name: fr['clients.animals.link_existing'],
}),
)
await userEvent.click(
await screen.findByRole('button', { name: /Tornado/ }),
)
await userEvent.click(
screen.getByRole('radio', { name: fr['clients.role.contact'] }),
)
fake.rpcResults.create_animal_client_relation = {
data: { id: R1, revision: 1 },
}
fake.rpcResults.list_client_animals = {
data: [item(R1, { relation_role: 'contact' })],
}
await userEvent.click(
screen.getByRole('button', { name: fr['relations.panel.save_animal'] }),
)
expect(
await screen.findByText(fr['relations.added_animal']),
).toBeInTheDocument()
expect(rpcArgs('create_animal_client_relation')[0]).toMatchObject({
animal_id: AID,
client_id: CID,
relation_role: 'contact',
})
expect(rpcArgs('search_animals')[0]).toMatchObject({
archived: false,
workspace_id: WS,
})
})
it('an archived client offers no add and no link', async () => {
fake.tables.clients = [clientRow({ archived_at: '2026-10-26T11:00:00Z' })]
fake.rpcResults.list_client_animals = { data: [item(R1)] }
mount(`/app/clients/${CID}`)
expect(
await screen.findByRole('link', { name: 'Tornado' }),
).toBeInTheDocument()
expect(
screen.queryByRole('link', { name: fr['clients.animals.add'] }),
).toBeNull()
expect(
screen.queryByRole('button', {
name: fr['clients.animals.link_existing'],
}),
).toBeNull()
})
})