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
// @vitest-environment happy-dom
import type { Proposal } from "@reactive-resume/resume/proposals";
import type { CoverLetter } from "@reactive-resume/schema/cover-letter/data";
import { act, cleanup, renderHook } from "@testing-library/react";
import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
import { i18n } from "@lingui/core";
import { ORPCError } from "@orpc/client";
import { copyCoverLetterStyle } from "@reactive-resume/resume/cover-letter";
import { defaultResumeData } from "@reactive-resume/schema/resume/default";
const mocks = vi.hoisted(() => ({ toast: vi.fn(), save: vi.fn() }));
vi.mock("@tanstack/react-query", () => ({ useQuery: () => ({ data: [] }) }));
vi.mock("@tanstack/react-router", () => ({ useSearch: () => ({}) }));
vi.mock("@/features/applications/queries", () => ({ applicationsListQueryOptions: () => ({}) }));
vi.mock("@/libs/orpc/client", () => ({ client: { coverLetters: { update: mocks.save } }, streamClient: {} }));
vi.mock("@reactive-resume/ui/components/toast", () => ({ toast: { add: mocks.toast } }));
vi.mock("@/features/resume/builder/draft", () => ({
useCurrentResume: vi.fn(),
useResumeStore: { getState: vi.fn() },
}));
vi.mock("@/features/resume/editor/check/issues", () => ({ getSectionName: vi.fn() }));
vi.mock("@/features/resume/editor/write/model", () => ({ describeEntry: vi.fn() }));
import { useLetterAssistantDocument } from "./document";
import { useLetterEditorStore } from "@/features/letters/store";
const store = () => useLetterEditorStore.getState();
const letter: CoverLetter = {
id: "letter",
name: "Letter",
recipient: "",
content: "<p>They've said "yes".</p>",
greeting: null,
signOff: null,
style: copyCoverLetterStyle(defaultResumeData),
layout: "structured",
recipientName: "",
recipientCompany: "",
letterDate: null,
sourceResumeId: null,
sourceApplicationId: null,
senderLinked: false,
designLinked: false,
isLocked: false,
revision: 1,
createdAt: new Date(),
updatedAt: new Date(),
};
const edit = (id: string, after: string): Proposal => ({
id,
before: letter.content,
after,
target: { sectionId: "letter", field: "content" },
location: "Letter",
why: "Clearer",
status: "pending",
source: "assistant",
});
beforeEach(() => {
vi.useFakeTimers();
vi.clearAllMocks();
window.localStorage.clear();
i18n.loadAndActivate({ locale: "en-US", messages: {} });
store().load(letter);
mocks.save.mockImplementation(async () => ({ ...store().letter, revision: 2 }));
});
afterEach(() => {
cleanup();
store().reset();
vi.useRealTimers();
});
it("applies ordered additions and a rewrite through the real letter store, retaining identity through refinements, saves and explicit toast Undo", async () => {
const { result } = renderHook(useLetterAssistantDocument);
const doc = result.current;
if (!doc) throw new Error("Missing letter adapter");
const first = edit("first", `${letter.content}<p>First</p>`);
const additions = [first, edit("second", `${letter.content}<p>Second</p>`)];
const rewrite = edit("rewrite", "<p>Rewritten</p>");
act(() => store().edit({ content: `<p>They've said "yes".</p>` }));
act(() => {
expect(doc.accept([rewrite, ...additions]).applied).toEqual([rewrite, ...additions]);
});
expect(store().letter?.content).toBe("<p>Rewritten</p><p>First</p><p>Second</p>");
const undo = mocks.toast.mock.lastCall?.[0].actionProps.onClick;
await act(async () => {
await store().flush();
});
act(() => undo());
expect(store().letter?.content).toBe(`<p>They've said "yes".</p>`);
expect(result.current?.stateOf({ ...first, status: "accepted" })).toBe("pending");
act(() => {
expect(doc.accept(additions).applied).toEqual(additions);
});
act(() => store().edit({ content: "<p>Refined anchor</p><p>Refined first</p><p>Second</p>" }));
expect(result.current?.stateOf(first)).toBe("accepted");
act(() => {
expect(doc.accept(additions)).toEqual({ applied: [], stale: [] });
});
await act(async () => {
await store().flush();
});
const refined = store().letter;
if (!refined) throw new Error("Missing refined letter");
act(() => store().load(refined));
expect(result.current?.stateOf({ ...first, status: "accepted" })).toBe("accepted");
});
it("pairs accepted letter sources with saves and toast Undo, excluding stale proposals", async () => {
act(() => store().load({ ...letter, aiOperationIds: ["prior-source"] }));
const { result } = renderHook(useLetterAssistantDocument);
const rewrite = { ...edit("source-rewrite", "<p>Rewritten</p>"), aiOperationIds: ["assistant-source"] };
const conflict = { ...edit("source-stale", "<p>Conflict</p>"), aiOperationIds: ["stale-source"] };
act(() => {
expect(result.current?.accept([rewrite, conflict])).toEqual({ applied: [rewrite], stale: [conflict] });
});
expect(store().letter?.aiOperationIds).toEqual(["prior-source", "assistant-source"]);
expect(mocks.save).not.toHaveBeenCalled();
const undo = mocks.toast.mock.lastCall?.[0].actionProps.onClick;
await act(async () => {
await store().flush();
});
expect(mocks.save.mock.lastCall?.[0].aiOperationIds).toEqual(["prior-source", "assistant-source"]);
act(() => undo());
expect(store().letter?.content).toBe(letter.content);
expect(store().letter?.aiOperationIds).toEqual(["prior-source"]);
await act(async () => {
await store().flush();
});
expect(mocks.save.mock.lastCall?.[0].aiOperationIds).toEqual(["prior-source"]);
});
it("reports genuine stale edits and refuses old callbacks after switching or locking letters", () => {
const { result } = renderHook(useLetterAssistantDocument);
const doc = result.current;
if (!doc) throw new Error("Missing letter adapter");
const rewrite = edit("rewrite", "<p>Rewritten</p>");
const conflict = edit("conflict", "<p>Conflicting rewrite</p>");
act(() => {
expect(doc.accept([rewrite, conflict])).toEqual({ applied: [rewrite], stale: [conflict] });
});
expect(mocks.toast.mock.lastCall?.[0].description).toContain("1 edit couldn't be placed");
act(() => store().load({ ...letter, id: "other" }));
act(() => {
expect(doc.accept([rewrite])).toEqual({ applied: [], stale: [] });
});
act(() => store().load({ ...letter, isLocked: true }));
act(() => {
expect(doc.accept([rewrite])).toEqual({ applied: [], stale: [] });
});
expect(store().letter?.isLocked).toBe(true);
expect(store().letter?.content).toBe("<p>Rewritten</p>");
});
it("keeps a surviving letter toast inside its original editing session", () => {
const { result } = renderHook(useLetterAssistantDocument);
const doc = result.current;
if (!doc) throw new Error("Missing letter adapter");
act(() => {
doc.accept([edit("session-rewrite", "<p>Rewritten</p>")]);
});
const undo = mocks.toast.mock.lastCall?.[0].actionProps.onClick;
const saved = store().letter;
if (!saved) throw new Error("Missing saved letter");
const originalSession = store().sessionId;
act(() => {
store().reset();
store().load(saved);
});
expect(store().sessionId).not.toBe(originalSession);
act(() => undo());
expect(store().letter?.content).toBe(saved.content);
});
it("does not record or toast a normalized no-op in the real letter adapter", () => {
const { result } = renderHook(useLetterAssistantDocument);
const noop = edit("noop", `<p>They've said "yes".</p>`);
act(() => store().edit({ content: noop.after }));
act(() => {
expect(result.current?.accept([noop]).applied).toEqual([]);
});
expect(store().proposalApplications[noop.id]).toBeUndefined();
expect(result.current?.stateOf(noop)).toBe("stale");
expect(mocks.toast.mock.lastCall?.[0].description).not.toContain("Edit applied");
});
it("retains an offscreen letter Undo and its failed synchronization across reset/reload", async () => {
const { result, unmount } = renderHook(useLetterAssistantDocument);
const doc = result.current;
if (!doc) throw new Error("Missing letter adapter");
const rewrite = edit("durable-undo", "<p>Rewritten</p>");
act(() => {
doc.accept([rewrite]);
});
const undo = mocks.toast.mock.lastCall?.[0].actionProps.onClick;
await act(async () => {
await store().flush();
});
unmount();
act(() => undo());
mocks.save.mockRejectedValueOnce(new Error("Offline"));
expect(await store().flush()).toBe(false);
expect(mocks.save.mock.lastCall?.[0].proposalApplications).toEqual({ "durable-undo": false });
const saved = store().letter;
if (!saved) throw new Error("Missing undone letter");
store().reset();
vi.setSystemTime(Date.now() + 8 * 86_400_000);
store().load(saved);
expect(store().proposalApplications[rewrite.id]).toBe(false);
expect(store().pendingProposalApplications[rewrite.id]).toBe(false);
expect(await store().flush()).toBe(true);
expect(mocks.save.mock.lastCall?.[0].proposalApplications).toEqual({ "durable-undo": false });
expect(store().pendingProposalApplications).toEqual({});
});
it("keeps an unconfirmed decision at its original revision even when fetched text matches", async () => {
const { result } = renderHook(useLetterAssistantDocument);
act(() => {
result.current?.accept([edit("unconfirmed", "<p>Saved</p>")]);
});
mocks.save.mockRejectedValueOnce(new Error("Response lost"));
await act(async () => {
expect(await store().flush()).toBe(false);
});
const saved = store().letter;
if (!saved) throw new Error("Missing submitted letter");
act(() => {
store().reset();
store().load({ ...saved, revision: saved.revision + 1 });
});
expect(store().status).toBe("conflict");
expect(store().letter?.revision).toBe(saved.revision);
expect(store().pendingProposalApplications).toEqual({ unconfirmed: "<p>Saved</p>" });
mocks.save.mockClear();
expect(await store().flush()).toBe(false);
expect(mocks.save).not.toHaveBeenCalled();
});
it("honors explicit Reload without reviving the discarded session's unsaved content", () => {
act(() => store().edit({ content: "<p>Unsaved</p>" }, { applied: [{ id: "discarded", after: "<p>Unsaved</p>" }] }));
act(() => store().load({ ...letter, revision: 2 }, { recover: false }));
expect(store().letter?.content).toBe(letter.content);
expect(store().pending).toEqual({});
expect(store().pendingProposalApplications).toEqual({});
act(() => {
store().reset();
store().load({ ...letter, revision: 2 });
});
expect(store().letter?.content).toBe(letter.content);
expect(store().proposalApplications).toEqual({});
});
it("a recovered old letter Undo may not use a later same-text revision", async () => {
const { result } = renderHook(useLetterAssistantDocument);
act(() => {
result.current?.accept([edit("receipt", "<p>New</p>")]);
});
await act(async () => {
await store().flush();
});
const undo = mocks.toast.mock.lastCall?.[0].actionProps.onClick;
act(() => undo());
mocks.save.mockRejectedValueOnce(new Error("offline"));
await act(async () => {
expect(await store().flush()).toBe(false);
});
act(() => store().reset());
mocks.save.mockClear();
const remote = { ...letter, revision: 8 };
act(() => store().load(remote));
await act(async () => {
await store().flush();
});
expect(mocks.save).not.toHaveBeenCalled();
});
it("recovers only authored letter fields alongside a queued receipt", async () => {
const remote = { ...letter, greeting: "Hello Rowan,", signOff: "With thanks," };
act(() => {
store().load(remote);
store().edit({ content: "<p>New</p>" }, { applied: [{ id: "receipt", after: "<p>New</p>" }] });
});
act(() => {
store().reset();
store().load(remote);
});
expect(store().letter?.greeting).toBe(remote.greeting);
expect(store().letter?.signOff).toBe(remote.signOff);
expect(store().pending).toEqual({ content: "<p>New</p>" });
expect(await store().flush()).toBe(true);
expect(mocks.save.mock.lastCall?.[0]).not.toHaveProperty("greeting");
expect(mocks.save.mock.lastCall?.[0].proposalApplications).toEqual({ receipt: "<p>New</p>" });
});
it("never vouches for letter edits an older app kept: they go out unchecked until the server takes them", async () => {
act(() => store().reset());
// An older app's recovery record: no proposalSafety.
window.localStorage.setItem(
"reactive-resume:unsaved:letter:letter:older-visit",
JSON.stringify({
letter,
pending: { content: "<p>Older app</p>" },
proposalApplications: {},
pendingProposalApplications: { held: true },
storedAt: Date.now(),
}),
);
act(() => store().load(letter));
expect(store().letter?.content).toBe("<p>Older app</p>");
await act(async () => {
await store().flush();
});
expect(mocks.save.mock.calls[0]?.[0]).not.toHaveProperty("proposalSafety");
expect(mocks.save.mock.calls[0]?.[0]).toMatchObject({
content: "<p>Older app</p>",
proposalApplications: { held: true },
});
// The server took it: what's typed next is this app's own.
act(() => store().edit({ content: "<p>Typed after updating</p>" }));
await act(async () => {
await store().flush();
});
expect(mocks.save.mock.calls[1]?.[0]).toMatchObject({ proposalSafety: "v1" });
});
it("keeps an older app's letter edits unchecked after a refusal, so Reload keeps them aside", async () => {
act(() => store().reset());
window.localStorage.setItem(
"reactive-resume:unsaved:letter:letter:older-visit",
JSON.stringify({ letter, pending: { content: "<p>Older app</p>" }, storedAt: Date.now() }),
);
act(() => store().load(letter));
mocks.save.mockRejectedValueOnce(new ORPCError("CONFLICT"));
await act(async () => {
await store().flush();
});
expect(store().status).toBe("conflict");
expect(store().letter?.content).toBe("<p>Older app</p>");
const kept = Object.entries(window.localStorage).filter(([key]) =>
key.startsWith("reactive-resume:unsaved:letter:letter:"),
);
expect(kept.length).toBeGreaterThan(0);
for (const [, raw] of kept) expect(JSON.parse(raw)).not.toHaveProperty("proposalSafety");
});