A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!
TypeScript agent-skillsaidsh-pluginhacktoberfestjavascriptmcp-serverreactresume-builderself-hostedtypescript
import type { DocumentItemProps } from "./document-card";
// @vitest-environment happy-dom
import type { DocumentsSearch } from "./documents-page";
import type { RouterOutput } from "@/libs/orpc/client";
import { act, fireEvent, render, screen, waitFor, cleanup, within } from "@testing-library/react";
import { afterEach, expect, it, vi } from "vite-plus/test";
import { i18n } from "@lingui/core";
import { I18nProvider } from "@lingui/react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { useState } from "react";
import { DocumentsPage } from "./documents-page";
import { DocumentLibraryProvider } from "./library-session";
import { TrashPage } from "./trash-page";
import { useDialogStore } from "@/dialogs/store";
import { orpc } from "@/libs/orpc/client";
const requests = vi.hoisted(() => ({
load: vi.fn(),
trash: vi.fn(),
restore: vi.fn(),
purge: vi.fn(),
navigate: vi.fn(),
newLetter: vi.fn(),
counts: vi.fn(async () => ({ resume: 0, letter: 19500, trash: 19500 })),
}));
vi.mock("@/libs/orpc/client", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/libs/orpc/client")>();
return {
...actual,
orpc: {
documents: {
page: {
queryKey: actual.orpc.documents.page.queryKey,
queryOptions: (options: Parameters<typeof actual.orpc.documents.page.queryKey>[0]) => ({
queryKey: actual.orpc.documents.page.queryKey(options),
queryFn: () => requests.load(options?.input),
}),
},
counts: {
queryOptions: () => ({
queryKey: ["document-counts"],
queryFn: () => requests.counts(),
}),
},
},
},
};
});
vi.mock("@tanstack/react-router", () => ({
Link: ({ children }: { children: React.ReactNode }) => <a href="/dashboard">{children}</a>,
useNavigate: () => requests.navigate,
useRouter: () => ({ subscribe: () => () => {} }),
}));
vi.mock("@/hooks/use-confirm", () => ({ useConfirm: () => vi.fn() }));
vi.mock("./use-start-document", () => ({
IMPORT_ACCEPT: ".pdf,.docx,.json",
useStartDocument: () => ({ newLetter: requests.newLetter, creating: false }),
}));
vi.mock("./document-actions", () => ({
TagsDialog: () => null,
LinkApplicationDialog: () => null,
useBatchActions: () => ({ trash: requests.trash, restore: requests.restore, purge: requests.purge }),
}));
vi.mock("./document-card", () => ({
DocumentRow: ({ document, selected, onSelectedChange, disabled }: DocumentItemProps) => (
<tr>
<td>
<input
type="checkbox"
aria-label={`Select ${document.name}`}
checked={selected}
disabled={disabled}
onChange={(event) => onSelectedChange?.(event.target.checked)}
/>
</td>
<td>
<a href={`/builder/${document.id}`}>{document.name}</a>
</td>
</tr>
),
DocumentCard: ({ document, selected, onSelectedChange, disabled }: DocumentItemProps) => (
<article>
<input
type="checkbox"
aria-label={`Select ${document.name}`}
checked={selected}
disabled={disabled}
onChange={(event) => onSelectedChange?.(event.target.checked)}
/>
{document.name}
</article>
),
}));
vi.mock("@/features/resume/builder/draft", () => ({ isEditableElementFocused: () => false }));
afterEach(cleanup);
type Page = RouterOutput["documents"]["page"];
function page(offset: number, total = 19500): Page {
return {
items: Array.from({ length: Math.min(100, total - offset) }, (_, i) => ({
id: `document-${offset + i}`,
type: "letter",
name: `Document ${offset + i}`,
tags: [],
isLocked: false,
isPublic: false,
hasPassword: false,
slug: null,
trashedAt: null,
createdAt: new Date(),
updatedAt: new Date(),
editedAt: new Date(),
recipient: null,
application: null,
})),
total,
counts: { resume: 0, letter: total },
tags: [],
hasPublic: false,
};
}
function setup(trashed = false, view: "grid" | "list" = "list", cacheNext = true, initialQuery = "") {
i18n.loadAndActivate({ locale: "en-US", messages: {} });
const client = new QueryClient({ defaultOptions: { queries: { staleTime: Infinity, retry: false } } });
const input = { trashed, type: "all" as const, q: "", tags: [], sort: "edited" as const, public: false, limit: 100 };
for (const offset of cacheNext ? [0, 100] : [0])
client.setQueryData(orpc.documents.page.queryKey({ input: { ...input, offset } }), page(offset));
// Trash uses defaults instead of explicit filters.
if (trashed)
for (const offset of cacheNext ? [0, 100] : [0])
client.setQueryData(orpc.documents.page.queryKey({ input: { trashed, limit: 100, offset } }), page(offset));
function Library() {
const [search, setSearch] = useState<DocumentsSearch>({
type: "all",
q: initialQuery,
tags: [],
sort: "edited",
view,
});
return (
<DocumentsPage search={search} onSearchChange={(patch) => setSearch((current) => ({ ...current, ...patch }))} />
);
}
render(
<I18nProvider i18n={i18n}>
<QueryClientProvider client={client}>
<DocumentLibraryProvider>{trashed ? <TrashPage /> : <Library />}</DocumentLibraryProvider>
</QueryClientProvider>
</I18nProvider>,
);
return { client, input };
}
it.each([
{ trashed: false, view: "list" },
{ trashed: false, view: "grid" },
{ trashed: true, view: "list" },
] as const)(
"bounds 19.5k documents to one page and replaces rows on Next ($view, trash=$trashed)",
async ({ trashed, view }) => {
setup(trashed, view);
const role = view === "grid" ? "article" : "row";
const count = view === "grid" ? 100 : 101;
expect(screen.getAllByRole(role)).toHaveLength(count);
if (!trashed) expect(within(screen.getByRole("tab", { name: /Letters/ })).getByText("19,500")).toBeVisible();
expect(screen.getByText("Document 0")).toBeVisible();
expect(screen.queryByText("Document 100")).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Next" }));
await waitFor(() => expect(screen.getByText("Document 100")).toBeVisible());
expect(screen.getAllByRole(role)).toHaveLength(count);
expect(screen.queryByText("Document 0")).toBeNull();
expect(screen.getByText("101–200 of 19,500")).toBeVisible();
},
);
it("search starts at page zero, preserves global filtered counts and clears page selection", async () => {
const { client, input } = setup();
fireEvent.click(screen.getByRole("button", { name: "Next" }));
await waitFor(() => expect(screen.getByText("Document 100")).toBeVisible());
fireEvent.click(screen.getByRole("checkbox", { name: "Select this page" }));
expect(screen.getByText("100 selected")).toBeVisible();
client.setQueryData(orpc.documents.page.queryKey({ input: { ...input, q: "needle", offset: 0 } }), {
...page(0, 1),
items: page(0, 1).items.map((row) => ({ ...row, name: "needle" })),
});
fireEvent.change(screen.getByRole("searchbox", { name: "Search documents" }), { target: { value: "needle" } });
await waitFor(() => expect(screen.getByText("needle")).toBeVisible());
expect(screen.getAllByRole("row")).toHaveLength(2);
expect(screen.queryByRole("navigation", { name: "Pagination" })).toBeNull();
expect(screen.queryByText("100 selected")).toBeNull();
});
it.each([
{ trashed: false, view: "list" },
{ trashed: false, view: "grid" },
{ trashed: true, view: "list" },
] as const)(
"blocks retained-row callbacks while another page loads ($view, trash=$trashed)",
async ({ trashed, view }) => {
let finish!: (value: Page) => void;
requests.load.mockReset().mockReturnValue(
new Promise<Page>((resolve) => {
finish = resolve;
}),
);
setup(trashed, view, false);
fireEvent.click(screen.getByRole("button", { name: "Next" }));
await waitFor(() => expect(requests.load).toHaveBeenCalledTimes(1));
expect(screen.getByText("Document 0")).toBeVisible();
expect(screen.getByRole("checkbox", { name: "Select Document 0" })).toBeDisabled();
if (view === "list")
fireEvent.click(
screen.getByRole("checkbox", { name: trashed ? "Select this page in Trash" : "Select this page" }),
);
fireEvent.click(screen.getByRole("checkbox", { name: "Select Document 0" }));
expect(screen.queryByText("100 selected")).toBeNull();
expect(screen.queryByText("1 selected")).toBeNull();
await act(async () => {
finish(page(100));
});
const current = await screen.findByRole("checkbox", { name: "Select Document 100" });
expect(current).not.toBeDisabled();
fireEvent.click(current);
expect(screen.getByText("1 selected")).toBeVisible();
},
);
it("blocks raw-search debounce and failed-fetch actions while retaining controls and last-successful metadata", async () => {
let fail!: (error: Error) => void;
requests.load.mockReset().mockReturnValue(
new Promise<Page>((_resolve, reject) => {
fail = reject;
}),
);
const { client, input } = setup();
act(() =>
client.setQueryData(orpc.documents.page.queryKey({ input: { ...input, offset: 0 } }), {
...page(0),
tags: ["design"],
}),
);
fireEvent.click(screen.getByRole("checkbox", { name: "Select Document 0" }));
expect(screen.getByText("1 selected")).toBeVisible();
const search = screen.getByRole("searchbox", { name: "Search documents" });
fireEvent.change(search, { target: { value: "new query" } });
expect(screen.getByRole("checkbox", { name: "Select Document 0" })).toBeDisabled();
fireEvent.click(screen.getByRole("checkbox", { name: "Select this page" }));
expect(screen.queryByText("100 selected")).toBeNull();
await waitFor(() => expect(requests.load).toHaveBeenCalledTimes(1));
await act(async () => {
fail(new Error("Network unavailable"));
});
expect(await screen.findByRole("alert")).toBeVisible();
expect(search).toBeVisible();
expect(search).toHaveValue("new query");
expect(screen.getByRole("button", { name: "#design" })).toBeVisible();
expect(within(screen.getByRole("tab", { name: /Letters/ })).getByText("19,500")).toBeVisible();
expect(screen.getByText("Document 0")).toBeVisible();
expect(screen.getByRole("checkbox", { name: "Select Document 0" })).toBeDisabled();
requests.load.mockResolvedValue(page(0));
fireEvent.change(search, { target: { value: "" } });
await waitFor(() => expect(screen.queryByRole("alert")).toBeNull());
expect(screen.getByRole("checkbox", { name: "Select Document 0" })).not.toBeDisabled();
expect(screen.queryByText("1 selected")).toBeNull();
});
it.each(["paste", "url"])("bounds %s searches to the server's 500-character limit", async (source) => {
requests.load.mockReset().mockResolvedValue(page(0));
setup(false, "list", true, source === "url" ? "x".repeat(501) : "");
const search = screen.getByRole("searchbox", { name: "Search documents" });
if (source === "paste") fireEvent.change(search, { target: { value: "x".repeat(501) } });
expect(search).toHaveAttribute("maxlength", "500");
expect(search).toHaveValue("x".repeat(500));
await waitFor(() => expect(requests.load).toHaveBeenCalled());
expect(requests.load.mock.calls.every(([input]) => input.q.length <= 500)).toBe(true);
});
it("retains rows, counts, tags and keyboard focus while the next page loads", async () => {
let finish: ((value: Page) => void) | undefined;
const response = new Promise<Page>((resolve) => {
finish = resolve;
});
requests.load.mockReset().mockReturnValue(response);
const { client, input } = setup(false, "list", false);
act(() => {
client.setQueryData(orpc.documents.page.queryKey({ input: { ...input, offset: 0 } }), {
...page(0),
tags: ["design"],
});
});
const next = screen.getByRole("button", { name: "Next" });
next.focus();
fireEvent.click(next);
await waitFor(() => expect(next).toHaveAttribute("aria-disabled", "true"));
expect(next).toHaveFocus();
expect(screen.getByText("Document 0")).toBeVisible();
expect(within(screen.getByRole("tab", { name: /Letters/ })).getByText("19,500")).toBeVisible();
expect(screen.getByRole("button", { name: "#design" })).toBeVisible();
fireEvent.click(next);
expect(requests.load).toHaveBeenCalledTimes(1);
await act(async () => {
finish?.(page(100));
});
expect(await screen.findByText("Document 100")).toBeVisible();
expect(screen.queryByText("Document 0")).toBeNull();
expect(next).toHaveFocus();
});
it.each([false, true])(
"returns to the previous page after its last remaining row is removed (trash=%s)",
async (trashed) => {
const { client, input } = setup(trashed);
fireEvent.click(screen.getByRole("button", { name: "Next" }));
await waitFor(() => expect(screen.getByText("Document 100")).toBeVisible());
const filters = trashed ? { trashed, limit: 100 } : input;
act(() => {
client.setQueryData(orpc.documents.page.queryKey({ input: { ...filters, offset: 0 } }), page(0, 100));
client.setQueryData(orpc.documents.page.queryKey({ input: { ...filters, offset: 100 } }), page(100, 100));
});
await waitFor(() => expect(screen.getByText("Document 0")).toBeVisible());
expect(screen.getAllByRole("row")).toHaveLength(101);
expect(screen.queryByRole("navigation", { name: "Pagination" })).toBeNull();
},
);
it("bounds tag selection to twenty while allowing selected tags to be removed", async () => {
requests.load
.mockReset()
.mockImplementation(async () => ({ ...page(0), tags: Array.from({ length: 21 }, (_, i) => `tag${i}`) }));
const { client, input } = setup();
act(() =>
client.setQueryData(orpc.documents.page.queryKey({ input: { ...input, offset: 0 } }), {
...page(0),
tags: Array.from({ length: 21 }, (_, i) => `tag${i}`),
}),
);
for (let i = 0; i < 20; i++) {
fireEvent.click(await screen.findByRole("button", { name: `#tag${i}` }));
await waitFor(() => expect(requests.load.mock.lastCall?.[0].tags).toHaveLength(i + 1));
}
fireEvent.click(screen.getByRole("button", { name: "#tag20" }));
expect(requests.load.mock.calls.every(([input]) => input.tags.length <= 20)).toBe(true);
expect(screen.getByRole("button", { name: "#tag20" })).toHaveAttribute("aria-pressed", "false");
fireEvent.click(screen.getByRole("button", { name: "#tag0" }));
await waitFor(() => expect(requests.load.mock.lastCall?.[0].tags).toHaveLength(19));
fireEvent.click(screen.getByRole("button", { name: "#tag20" }));
await waitFor(() => expect(requests.load.mock.lastCall?.[0].tags).toContain("tag20"));
});
it("opens the top match with Enter, even before the typed search returns, then ↓ and Esc work from the field", async () => {
let finish!: (value: Page) => void;
requests.navigate.mockReset();
requests.load.mockReset().mockReturnValue(
new Promise<Page>((resolve) => {
finish = resolve;
}),
);
setup();
const search = screen.getByRole("searchbox", { name: "Search documents" });
search.focus();
fireEvent.change(search, { target: { value: "riot" } });
// An IME confirming its conversion and modified Enter keep their own meaning.
fireEvent.keyDown(search, { key: "Enter", keyCode: 229 });
fireEvent.keyDown(search, { key: "Enter", metaKey: true });
expect(requests.load).not.toHaveBeenCalled();
// Enter skips the typing delay and waits for the result instead of opening a stale row.
fireEvent.keyDown(search, { key: "Enter" });
await waitFor(() => expect(requests.load).toHaveBeenCalledWith(expect.objectContaining({ q: "riot", offset: 0 })));
expect(requests.navigate).not.toHaveBeenCalled();
await act(async () => {
finish({ ...page(0, 1), items: page(0, 1).items.map((row) => ({ ...row, id: "riot", name: "Riot — Gameplay" })) });
});
await waitFor(() =>
expect(requests.navigate).toHaveBeenCalledWith({
to: "/builder/letter/$coverLetterId",
params: { coverLetterId: "riot" },
}),
);
expect(requests.navigate).toHaveBeenCalledOnce();
fireEvent.keyDown(search, { key: "ArrowDown" });
expect(screen.getByRole("link", { name: "Riot — Gameplay" })).toHaveFocus();
search.focus();
fireEvent.keyDown(search, { key: "Escape" });
expect(search).toHaveValue("");
expect(search).toHaveFocus();
fireEvent.keyDown(search, { key: "Escape" });
expect(search).not.toHaveFocus();
expect(requests.navigate).toHaveBeenCalledOnce();
});
it("does not carry queued navigation into a replacement query client", async () => {
let finish!: (value: Page) => void;
requests.navigate.mockReset();
requests.load.mockReset().mockReturnValue(
new Promise<Page>((resolve) => {
finish = resolve;
}),
);
i18n.loadAndActivate({ locale: "en-US", messages: {} });
const first = new QueryClient({ defaultOptions: { queries: { retry: false } } });
const second = new QueryClient({ defaultOptions: { queries: { retry: false } } });
const tree = (client: QueryClient) => (
<I18nProvider i18n={i18n}>
<QueryClientProvider client={client}>
<DocumentLibraryProvider>
<DocumentsPage
search={{ type: "all", q: "Shared", tags: [], sort: "edited", view: "list" }}
onSearchChange={vi.fn()}
/>
</DocumentLibraryProvider>
</QueryClientProvider>
</I18nProvider>
);
const view = render(tree(first));
await waitFor(() => expect(requests.load).toHaveBeenCalled());
fireEvent.keyDown(screen.getByRole("searchbox", { name: "Search documents" }), { key: "Enter" });
view.rerender(tree(second));
await act(async () => finish(page(0, 1)));
await screen.findByText("Document 0");
expect(requests.navigate).not.toHaveBeenCalled();
view.unmount();
first.clear();
second.clear();
});
it.each(["empty", "error"])(
"a completed %s request cannot lend its Enter to later same-request data",
async (completion) => {
let finish!: (value: Page) => void;
let fail!: (error: Error) => void;
requests.navigate.mockReset();
requests.load.mockReset().mockReturnValue(
new Promise<Page>((resolve, reject) => {
finish = resolve;
fail = reject;
}),
);
const { client, input } = setup(false, "list", false, "Shared");
await waitFor(() => expect(requests.load).toHaveBeenCalled());
const search = screen.getByRole("searchbox", { name: "Search documents" });
fireEvent.keyDown(search, { key: "Enter" });
await act(async () => {
if (completion === "empty") finish(page(0, 0));
else fail(new Error("Owned search failure"));
});
if (completion === "error") {
await screen.findByRole("alert");
fireEvent.keyDown(search, { key: "Enter" });
} else await screen.findByText("Nothing matches “Shared”");
act(() =>
client.setQueryData(orpc.documents.page.queryKey({ input: { ...input, q: "Shared", offset: 0 } }), page(0, 1)),
);
await screen.findByText("Document 0");
expect(requests.navigate).not.toHaveBeenCalled();
},
);
it.each([
{ type: "letter", title: "No cover letters yet", action: "New cover letter" },
{ type: "resume", title: "No resumes yet", action: "New resume" },
] as const)("an empty $type tab offers to make one instead of clearing filters", async ({ type, title, action }) => {
i18n.loadAndActivate({ locale: "en-US", messages: {} });
const client = new QueryClient({ defaultOptions: { queries: { staleTime: Infinity, retry: false } } });
const input = {
trashed: false,
type,
q: "",
tags: [],
sort: "edited" as const,
public: false,
limit: 100,
offset: 0,
};
const counts = type === "letter" ? { resume: 3, letter: 0 } : { resume: 0, letter: 2 };
client.setQueryData(orpc.documents.page.queryKey({ input }), {
items: [],
total: 0,
counts,
tags: [],
hasPublic: false,
});
render(
<I18nProvider i18n={i18n}>
<QueryClientProvider client={client}>
<DocumentLibraryProvider>
<DocumentsPage search={{ type, q: "", tags: [], sort: "edited", view: "grid" }} onSearchChange={vi.fn()} />
</DocumentLibraryProvider>
</QueryClientProvider>
</I18nProvider>,
);
expect(await screen.findByRole("heading", { name: title })).toBeVisible();
expect(screen.queryByText("Nothing matches these filters")).toBeNull();
expect(screen.queryByRole("button", { name: "Clear search and filters" })).toBeNull();
if (type === "letter") {
fireEvent.click(screen.getByRole("button", { name: action }));
expect(requests.newLetter).toHaveBeenCalledOnce();
} else expect(screen.getByRole("button", { name: action })).toBeEnabled();
});
it("first run's Choose a file opens the file picker, then imports the chosen file", async () => {
i18n.loadAndActivate({ locale: "en-US", messages: {} });
const client = new QueryClient({ defaultOptions: { queries: { staleTime: Infinity, retry: false } } });
const input = {
trashed: false,
type: "all" as const,
q: "",
tags: [],
sort: "edited" as const,
public: false,
limit: 100,
offset: 0,
};
const empty = { items: [], total: 0, counts: { resume: 0, letter: 0 }, tags: [], hasPublic: false };
client.setQueryData(orpc.documents.page.queryKey({ input }), empty);
client.setQueryData(orpc.documents.counts.queryOptions().queryKey, { resume: 0, letter: 0, trash: 0 });
const pick = vi.spyOn(HTMLInputElement.prototype, "click").mockImplementation(() => undefined);
render(
<I18nProvider i18n={i18n}>
<QueryClientProvider client={client}>
<DocumentLibraryProvider>
<DocumentsPage
search={{ type: "all", q: "", tags: [], sort: "edited", view: "grid" }}
onSearchChange={vi.fn()}
/>
</DocumentLibraryProvider>
</QueryClientProvider>
</I18nProvider>,
);
fireEvent.click(await screen.findByRole("button", { name: "Choose a file" }));
expect(pick).toHaveBeenCalledOnce();
expect(useDialogStore.getState().open).toBe(false);
const file = new File(["{}"], "resume.json", { type: "application/json" });
fireEvent.change(screen.getByLabelText("Choose a file to import"), { target: { files: [file] } });
expect(useDialogStore.getState().activeDialog).toEqual({ type: "document.new", data: { file } });
pick.mockRestore();
act(() => useDialogStore.getState().closeDialog());
});
it.each([0, 1])("recovers the correct empty state after a failed counts request (trash=%i)", async (trash) => {
requests.load.mockReset().mockResolvedValue(page(0, 0));
requests.counts
.mockRejectedValueOnce(new Error("Counts unavailable"))
.mockResolvedValueOnce({ resume: 0, letter: 0, trash });
i18n.loadAndActivate({ locale: "en-US", messages: {} });
const client = new QueryClient({ defaultOptions: { queries: { staleTime: Infinity, retry: false } } });
const input = {
trashed: false,
type: "all" as const,
q: "",
tags: [],
sort: "edited" as const,
public: false,
limit: 100,
offset: 0,
};
client.setQueryData(orpc.documents.page.queryKey({ input }), page(0, 0));
render(
<I18nProvider i18n={i18n}>
<QueryClientProvider client={client}>
<DocumentLibraryProvider>
<DocumentsPage
search={{ type: "all", q: "", tags: [], sort: "edited", view: "grid" }}
onSearchChange={vi.fn()}
/>
</DocumentLibraryProvider>
</QueryClientProvider>
</I18nProvider>,
);
expect(await screen.findByRole("alert")).toBeVisible();
fireEvent.click(screen.getByRole("button", { name: "Try again" }));
if (trash === 0) expect(await screen.findByRole("button", { name: "Choose a file" })).toBeVisible();
else {
expect(await screen.findByRole("heading", { name: "No documents" })).toBeVisible();
expect(await screen.findByText("Trash has 1 document.")).toBeVisible();
expect(screen.queryByRole("button", { name: "Choose a file" })).toBeNull();
}
});
it.each(["list", "grid"] as const)(
"groups a job's resume and letter in %s view, keeping closed jobs collapsed until opened",
async (view) => {
i18n.loadAndActivate({ locale: "en-US", messages: {} });
const client = new QueryClient({ defaultOptions: { queries: { staleTime: Infinity, retry: false } } });
const input = {
trashed: false,
type: "all" as const,
q: "",
tags: [],
sort: "edited" as const,
public: false,
limit: 100,
offset: 0,
};
const base = page(0, 1).items[0];
if (!base) throw new Error("missing document fixture");
const document = (
id: string,
type: "resume" | "letter",
application: { id: string; company: string; role: string; status: "applied" | "closed" } | null,
) => ({
...base,
id,
type,
name: `${application?.company ?? "Loose"} ${type}`,
application,
});
client.setQueryData(orpc.documents.page.queryKey({ input }), {
...page(0, 4),
items: [
document("open-resume", "resume", { id: "open", company: "Open Co", role: "Engineer", status: "applied" }),
document("closed-resume", "resume", { id: "closed", company: "Closed Co", role: "Designer", status: "closed" }),
document("loose-letter", "letter", null),
document("open-letter", "letter", { id: "open", company: "Open Co", role: "Engineer", status: "applied" }),
document("closed-letter", "letter", { id: "closed", company: "Closed Co", role: "Designer", status: "closed" }),
],
total: 5,
});
render(
<I18nProvider i18n={i18n}>
<QueryClientProvider client={client}>
<DocumentLibraryProvider>
<DocumentsPage search={{ type: "all", q: "", tags: [], sort: "edited", view }} onSearchChange={vi.fn()} />
</DocumentLibraryProvider>
</QueryClientProvider>
</I18nProvider>,
);
const closed = await screen.findByRole("button", { name: /Closed Co/ });
expect(closed).toHaveAttribute("aria-expanded", "false");
expect(screen.getByText("Open Co resume")).toBeVisible();
expect(screen.getByText("Open Co letter")).toBeVisible();
expect(screen.queryByText("Closed Co resume")).toBeNull();
expect(screen.queryByText("Closed Co letter")).toBeNull();
expect(screen.getByText("Loose letter")).toBeVisible();
// Select this page covers the open groups only: the closed group's documents stay out of the selection.
if (view === "list") fireEvent.click(screen.getByRole("checkbox", { name: "Select this page" }));
else {
fireEvent.click(screen.getByRole("checkbox", { name: "Select Open Co resume" }));
fireEvent.click(screen.getByRole("button", { name: "Select this page" }));
}
for (const name of ["Open Co resume", "Open Co letter", "Loose letter"])
expect(screen.getByRole("checkbox", { name: `Select ${name}` })).toBeChecked();
expect(screen.queryByRole("checkbox", { name: "Select Closed Co resume" })).toBeNull();
fireEvent.click(closed);
expect(closed).toHaveAttribute("aria-expanded", "true");
expect(await screen.findByText("Closed Co resume")).toBeVisible();
expect(screen.getByText("Closed Co letter")).toBeVisible();
},
);