Files
HealthLog/src/components/encounters/__tests__/procedures-section.test.tsx
T
Marc-André Bombeck a1b56f0b75 fix(visits): keep the since-last-visit card on a failed read
A failed read replaced the card and its title with a bare row, so the
section changed height and the reader lost what had failed. The card now
keeps its header and shows the error inside. The visit card's header
moves onto TileHeader instead of its own icon and title row.
2026-10-20 10:10:36 +02:00

206 lines
6.7 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { renderToStaticMarkup } from "react-dom/server";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
/**
* The procedure history's designed states, pinned by single-pass static
* renders (the repository's component-test convention; typing into the filter
* is driven in the browser check, not here).
*
* - an account with no procedure gets an empty state that says how to make
* one — including switching a visit already on file — and one action;
* - a history lists what the server sent, in the server's order, each row
* naming its body site with the side;
* - the body sites are offered as filter choices, with "All" pressed while
* nothing is filtered;
* - a failed read is an error with a retry, never the empty state.
*
* Mutation checks (each run, each seen red):
* - render `procedures.length === 0` as the account-empty state instead of
* keying it on `total` → "keeps the filter when nothing matches" goes red;
* - drop the side from `bodySiteText` → "names the site with its side" goes
* red.
*/
vi.mock("@/hooks/use-auth", () => ({
useAuth: () => ({
user: { id: "u1", modules: {} },
isLoading: false,
isAuthenticated: true,
}),
}));
vi.mock("@/hooks/use-record-capabilities", () => ({
useRecordCapabilities: () => ({
canManage: true,
canWrite: true,
canWriteDomain: () => true,
canManageDomain: () => true,
}),
}));
vi.mock("@/lib/api/api-fetch", async () => {
const actual = await vi.importActual<typeof import("@/lib/api/api-fetch")>(
"@/lib/api/api-fetch",
);
return {
...actual,
apiGet: () => new Promise(() => {}),
apiPost: vi.fn(),
apiPatch: vi.fn(),
apiDelete: vi.fn(),
};
});
import { I18nProvider } from "@/lib/i18n/context";
import { queryKeys } from "@/lib/query-keys";
import type { EncounterDTO, ProcedureListDTO } from "@/lib/encounters/dto";
import { ProceduresSection } from "../procedures-section";
function procedure(over: Partial<EncounterDTO> & { id: string }): EncounterDTO {
return {
occurredAt: "2011-03-14T09:00:00.000Z",
status: "DONE",
kind: "PROCEDURE",
practitioner: null,
reason: null,
outcome: null,
bodySite: null,
laterality: null,
reminderNextDueAt: null,
createdAt: "2011-03-14T09:00:00.000Z",
updatedAt: "2011-03-14T09:00:00.000Z",
...over,
};
}
function render(data: ProcedureListDTO | "error") {
const queryClient = new QueryClient({
// `retryOnMount: false` so a seeded error stays an error through the
// render instead of being reported as a fresh fetch.
defaultOptions: { queries: { retry: false, retryOnMount: false } },
});
const key = queryKeys.encounterProcedures("", null);
if (data === "error") {
queryClient
.getQueryCache()
.build(queryClient, { queryKey: key })
.setState({
status: "error",
error: new Error("boom"),
fetchStatus: "idle",
});
} else {
queryClient.setQueryData(key, data);
}
return renderToStaticMarkup(
<QueryClientProvider client={queryClient}>
<I18nProvider initialLocale="en">
<ProceduresSection />
</I18nProvider>
</QueryClientProvider>,
);
}
describe("<ProceduresSection>", () => {
it("explains how to get a first procedure, including switching a visit", () => {
const html = render({ procedures: [], bodySites: [], total: 0 });
expect(html).toContain("No procedure recorded yet");
expect(html).toContain("switch an existing visit to it");
expect(html).toContain('data-slot="procedures-add"');
expect(html).not.toContain('data-slot="procedures-filter"');
expect(html).not.toContain("Procedures could not be loaded.");
});
it("lists the history in the server's order and names the site with its side", () => {
const html = render({
procedures: [
procedure({
id: "newer",
occurredAt: "2019-07-02T09:00:00.000Z",
reason: "Cholecystectomy",
bodySite: "Gallbladder",
}),
procedure({
id: "older",
reason: "Meniscus repair",
bodySite: "Knee",
laterality: "LEFT",
}),
],
bodySites: [
{ bodySite: "Gallbladder", laterality: null, count: 1 },
{ bodySite: "Knee", laterality: "LEFT", count: 1 },
],
total: 2,
});
expect(html.indexOf('data-encounter-id="newer"')).toBeLessThan(
html.indexOf('data-encounter-id="older"'),
);
expect(html).toContain("Meniscus repair");
expect(html).toContain("Knee (Left)");
expect(html).toContain("2 of 2");
});
it("heads a procedure with what was done, and keeps the practice on its own line", () => {
const html = render({
procedures: [
procedure({
id: "p1",
reason: "Meniscus repair",
practitioner: {
id: "pr1",
name: "Sample clinic",
specialty: null,
practice: null,
location: null,
phone: null,
note: null,
createdAt: "2011-01-01T00:00:00.000Z",
updatedAt: "2011-01-01T00:00:00.000Z",
},
}),
],
bodySites: [],
total: 1,
});
expect(html).toMatch(/card-title"[^>]*>Meniscus repair</);
expect(html).toContain("Sample clinic");
expect(html.match(/Meniscus repair/g)).toHaveLength(1);
});
it("offers every body site as a filter, with All pressed while nothing is filtered", () => {
const html = render({
procedures: [
procedure({ id: "p1", bodySite: "Knee", laterality: "LEFT" }),
],
bodySites: [{ bodySite: "Knee", laterality: "LEFT", count: 1 }],
total: 1,
});
expect(html).toContain('data-slot="procedures-filter"');
expect(html).toMatch(
/data-slot="procedures-site-all"[^>]*aria-pressed="true"|aria-pressed="true"[^>]*data-slot="procedures-site-all"/,
);
expect(html).toMatch(
/aria-pressed="false"[^>]*>Knee \(Left\)|data-slot="procedures-site"[^>]*aria-pressed="false"/,
);
});
it("keeps the filter when nothing matches, and offers to clear it", () => {
const html = render({
procedures: [],
bodySites: [{ bodySite: "Knee", laterality: null, count: 1 }],
total: 1,
});
expect(html).toContain("Nothing matches this filter");
expect(html).toContain('data-slot="procedures-filter"');
expect(html).not.toContain("No procedure recorded yet");
});
it("paints an error with a retry, never the empty state", () => {
const html = render("error");
expect(html).toContain("Procedures could not be loaded.");
expect(html).not.toContain("No procedure recorded yet");
});
});