Skip to content

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!

10.4 KB
Raw Blame
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
// @vitest-environment happy-dom
import { i18n } from "@lingui/core";
import { I18nProvider } from "@lingui/react";

const mocks = vi.hoisted(() => ({
	create: vi.fn(),
	link: vi.fn(),
	read: vi.fn(),
	metadata: vi.fn(),
	navigate: vi.fn(),
	saved: vi.fn(),
	account: "owner",
	generation: 1,
	resume: { id: "resume", isLocked: false },
}));
vi.mock("@tanstack/react-query", () => ({ useQueryClient: () => ({ invalidateQueries: vi.fn() }) }));
vi.mock("@tanstack/react-router", () => ({
	useNavigate: () => mocks.navigate,
	useSearch: () => ({ applicationId: "old-job" }),
}));
vi.mock("@/libs/auth/account-scope", () => ({
	getAccountId: () => mocks.account,
	getAccountGeneration: () => mocks.generation,
}));
vi.mock("@/features/resume/builder/draft", () => ({
	usePatchResume: () => vi.fn(),
	saveResumeMetadata: mocks.metadata,
	useResumeStore: { getState: () => ({ resume: mocks.resume }) },
}));
vi.mock("@/libs/error-message", () => ({ toastError: vi.fn() }));
vi.mock("@reactive-resume/ui/components/toast", () => ({ toast: { add: vi.fn() } }));
vi.mock("@/libs/orpc/client", () => ({
	client: {
		applications: { create: mocks.create },
		documents: { linkApplication: mocks.link },
		resume: { getById: mocks.read },
	},
	orpc: { applications: { key: () => ["applications"] }, documents: { key: () => ["documents"] } },
}));
import { SavePosting } from "./save-posting";

const posting = {
	sourceUrl: "https://jobs.example/role",
	jobDescription: "External <script>write data</script> posting",
	postingSource: {
		requestedUrl: "https://jobs.example/role",
		method: "builtin" as const,
		format: "text" as const,
		retrievedAt: "2026-11-03T00:00:00Z",
		truncated: false,
		completeness: "unknown" as const,
	},
};
beforeEach(() => {
	vi.clearAllMocks();
	mocks.account = "owner";
	mocks.generation = 1;
	mocks.resume = { id: "resume", isLocked: false };
	i18n.loadAndActivate({ locale: "en-US", messages: {} });
	mocks.create.mockResolvedValue("new-job");
	mocks.link.mockResolvedValue({ id: "resume", applicationId: "new-job" });
	mocks.read.mockResolvedValue({ id: "resume", applicationId: null, isLocked: false });
	mocks.navigate.mockResolvedValue(undefined);
	mocks.metadata.mockImplementation(async (_id, write) => write(new Date(0), { signal: new AbortController().signal }));
});
afterEach(cleanup);
function open(disabled = false) {
	render(
		<I18nProvider i18n={i18n}>
			<SavePosting posting={posting} resumeId="resume" disabled={disabled} onSaved={mocks.saved} />
		</I18nProvider>,
	);
	fireEvent.click(screen.getByRole("button", { name: "Save as a job…" }));
}
function fill() {
	fireEvent.change(screen.getByLabelText("Company"), { target: { value: "Fictional Labs" } });
	fireEvent.change(screen.getByLabelText("Role"), { target: { value: "Engineer" } });
}
const submit = () => fireEvent.click(screen.getByRole("button", { name: "Save and link this resume" }));

it("confirms a committed link after its response is lost without another create or link", async () => {
	mocks.link.mockRejectedValueOnce(new Error("response lost after commit"));
	mocks.read.mockResolvedValue({ id: "resume", applicationId: "new-job", isLocked: false, updatedAt: new Date(1) });
	open();
	fill();
	submit();
	await waitFor(() => expect(mocks.saved).toHaveBeenCalledOnce());
	expect(mocks.create).toHaveBeenCalledOnce();
	expect(mocks.link).toHaveBeenCalledOnce();
	expect(mocks.read).toHaveBeenCalledWith(
		{ id: "resume" },
		expect.objectContaining({ context: { accountId: "owner" } }),
	);
});

it("rechecks an uncertain committed link before flushing pending edits on retry", async () => {
	mocks.link.mockRejectedValueOnce(new Error("lost response"));
	mocks.read
		.mockRejectedValueOnce(new Error("readback unavailable"))
		.mockResolvedValue({ id: "resume", applicationId: "new-job", isLocked: false, updatedAt: new Date(1) });
	open();
	fill();
	submit();
	await waitFor(() => expect(screen.getByRole("button", { name: "Save and link this resume" })).toBeEnabled());
	expect(mocks.saved).not.toHaveBeenCalled();
	submit();
	await waitFor(() => expect(mocks.saved).toHaveBeenCalledOnce());
	expect(mocks.metadata.mock.calls.map((call) => call[2])).toEqual([{ savePending: true }, { savePending: false }]);
	expect(mocks.create).toHaveBeenCalledOnce();
	expect(mocks.link).toHaveBeenCalledOnce();
});

it("retries the conditional link when its pre-link readback is unavailable", async () => {
	mocks.link.mockRejectedValueOnce(new Error("link unavailable"));
	mocks.read.mockRejectedValue(new Error("readback unavailable"));
	open();
	fill();
	submit();
	await waitFor(() => expect(screen.getByRole("button", { name: "Save and link this resume" })).toBeEnabled());
	submit();
	await waitFor(() => expect(mocks.saved).toHaveBeenCalledOnce());
	expect(mocks.create).toHaveBeenCalledOnce();
	expect(mocks.link).toHaveBeenCalledTimes(2);
	expect(mocks.link.mock.calls[1]?.[0]).toEqual({
		type: "resume",
		id: "resume",
		applicationId: "new-job",
		expectedUpdatedAt: new Date(0),
	});
});

it.each(["account", "document", "locked", "abort", "signal"])(
	"failed retry readback cannot link after %s changes",
	async (change) => {
		mocks.link.mockRejectedValueOnce(new Error("link unavailable"));
		mocks.read.mockRejectedValue(new Error("readback unavailable"));
		open();
		fill();
		submit();
		await waitFor(() => expect(screen.getByRole("button", { name: "Save and link this resume" })).toBeEnabled());
		const controller = new AbortController();
		mocks.metadata.mockImplementationOnce(async (_id, write) => write(new Date(0), { signal: controller.signal }));
		mocks.read.mockImplementationOnce(async () => {
			if (change === "account") mocks.account = "other";
			if (change === "document") mocks.resume = { id: "other", isLocked: false };
			if (change === "locked") mocks.resume.isLocked = true;
			if (change === "signal") controller.abort();
			throw new DOMException("unavailable", change === "abort" ? "AbortError" : "NetworkError");
		});
		await act(async () => {
			submit();
		});
		expect(mocks.create).toHaveBeenCalledOnce();
		expect(mocks.link).toHaveBeenCalledOnce();
		expect(mocks.saved).not.toHaveBeenCalled();
	},
);

it.each(["other application", "other document", "locked", "account changed"])(
	"never confirms readback for %s",
	async (change) => {
		mocks.link.mockRejectedValueOnce(new Error("link failed"));
		mocks.read.mockImplementationOnce(async () => {
			if (change === "account changed") mocks.account = "other";
			return {
				id: change === "other document" ? "other" : "resume",
				applicationId: change === "other application" ? "other" : "new-job",
				isLocked: change === "locked",
			};
		});
		open();
		fill();
		submit();
		await waitFor(() => expect(mocks.read).toHaveBeenCalledOnce());
		expect(mocks.saved).not.toHaveBeenCalled();
	},
);

it("cancel and empty fields create nothing; explicit confirmation saves plain snapshot and owned link", async () => {
	open();
	expect(screen.getByRole("button", { name: "Save and link this resume" })).toBeDisabled();
	expect(document.querySelector("script")).toBeNull();
	fill();
	await act(async () => {
		fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
	});
	expect(mocks.metadata).not.toHaveBeenCalled();
	expect(mocks.create).not.toHaveBeenCalled();
	expect(mocks.link).not.toHaveBeenCalled();
	expect(mocks.saved).not.toHaveBeenCalled();
	fireEvent.click(screen.getByRole("button", { name: "Save as a job…" }));
	fill();
	submit();
	submit();
	expect(screen.getByRole("button", { name: "Save and link this resume" })).toHaveAttribute("aria-busy", "true");
	await waitFor(() =>
		expect(mocks.saved).toHaveBeenCalledWith({ id: "new-job", company: "Fictional Labs", role: "Engineer" }),
	);
	expect(mocks.create).toHaveBeenCalledOnce();
	expect(mocks.create).toHaveBeenCalledWith(
		expect.objectContaining({ ...posting, resumeId: "resume", newId: expect.any(String) }),
		expect.objectContaining({ context: { accountId: "owner" }, signal: expect.any(AbortSignal) }),
	);
	expect(mocks.link).toHaveBeenCalledWith(
		{ type: "resume", id: "resume", applicationId: "new-job", expectedUpdatedAt: new Date(0) },
		expect.objectContaining({ context: { accountId: "owner" } }),
	);
	expect(mocks.navigate.mock.calls[0]?.[0].search({ applicationId: "old-job", assistant: "thread" })).toEqual({
		applicationId: "new-job",
		assistant: "thread",
	});
});

it("failed link retains exact saved application for retry without enabling posting or creating again", async () => {
	mocks.link.mockRejectedValueOnce(new Error("revision conflict"));
	open();
	fill();
	submit();
	await waitFor(() => expect(screen.getByRole("button", { name: "Save and link this resume" })).toBeEnabled());
	expect(mocks.saved).not.toHaveBeenCalled();
	expect(screen.getByLabelText("Company")).toBeDisabled();
	submit();
	await waitFor(() => expect(mocks.saved).toHaveBeenCalledOnce());
	expect(mocks.create).toHaveBeenCalledOnce();
	expect(mocks.link).toHaveBeenCalledTimes(2);
});

it("lost create response retries identical receipt; metadata failure sends no create", async () => {
	mocks.create.mockRejectedValueOnce(new Error("lost response"));
	open();
	fill();
	submit();
	await waitFor(() => expect(screen.getByRole("button", { name: "Save and link this resume" })).toBeEnabled());
	expect(mocks.link).not.toHaveBeenCalled();
	submit();
	await waitFor(() => expect(mocks.saved).toHaveBeenCalledOnce());
	expect(mocks.create.mock.calls[0]?.[0]).toEqual(mocks.create.mock.calls[1]?.[0]);
	cleanup();
	vi.clearAllMocks();
	mocks.metadata.mockRejectedValueOnce(new Error("body save conflict"));
	open();
	fill();
	submit();
	await waitFor(() => expect(mocks.metadata).toHaveBeenCalledOnce());
	expect(mocks.create).not.toHaveBeenCalled();
	expect(mocks.saved).not.toHaveBeenCalled();
});

it.each(["account", "generation", "document", "locked"])(
	"stops link and context update when %s changes during creation",
	async (change) => {
		mocks.create.mockImplementationOnce(async () => {
			if (change === "account") mocks.account = "other";
			if (change === "generation") mocks.generation++;
			if (change === "document") mocks.resume.id = "other";
			if (change === "locked") mocks.resume.isLocked = true;
			return "new-job";
		});
		open();
		fill();
		submit();
		await waitFor(() => expect(mocks.create).toHaveBeenCalledOnce());
		expect(mocks.link).not.toHaveBeenCalled();
		expect(mocks.saved).not.toHaveBeenCalled();
	},
);