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!

6.9 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";

const dbMock = vi.hoisted(() => ({ select: vi.fn(), update: vi.fn(), transaction: vi.fn() }));
const resumeServiceMock = vi.hoisted(() => ({
	getById: vi.fn(),
	create: vi.fn(),
	delete: vi.fn(),
	deleteTrashedMany: vi.fn(),
	setLocked: vi.fn(),
}));
const applicationServiceMock = vi.hoisted(() => ({ update: vi.fn() }));
const insertApplicationMock = vi.hoisted(() => vi.fn());
vi.mock("@reactive-resume/db/client", () => ({ db: dbMock }));
const writeResumeFieldsMock = vi.hoisted(() => vi.fn(async () => ({ id: "new", updatedAt: new Date() })));
vi.mock("../resume/service", () => ({ resumeService: resumeServiceMock, writeResumeFields: writeResumeFieldsMock }));
vi.mock("../cover-letters/service", () => ({ coverLetterService: { getById: vi.fn(), update: vi.fn() } }));
vi.mock("../applications/service", () => ({
	applicationService: applicationServiceMock,
	insertApplication: insertApplicationMock,
}));

const { documentsService } = await import("./service");

// `select().from().where()` resolving to `rows`.
const rows = (result: unknown[]) => ({ from: () => ({ where: () => Promise.resolve(result) }) });

const updates = () => {
	const set = vi.fn((_changes: Record<string, unknown>) => ({
		where: () => ({ returning: async () => [{ id: "copy" }] }),
	}));
	dbMock.update.mockReturnValue({ set });
	return set;
};

beforeEach(() => {
	for (const mock of [
		...Object.values(dbMock),
		...Object.values(resumeServiceMock),
		...Object.values(applicationServiceMock),
	])
		mock.mockReset();
	dbMock.transaction.mockImplementation(async (callback: (tx: unknown) => Promise<unknown>) =>
		callback({
			select: () => ({
				from: () => ({
					where: () =>
						Object.assign(Promise.resolve([{ id: "a1", company: "Orbital" }]), { for: async () => [{ id: "u1" }] }),
				}),
			}),
			update: dbMock.update,
		}),
	);
});

describe("Trash", () => {
	it("won't move a locked document, and keeps the resume's error code", async () => {
		dbMock.select.mockReturnValueOnce(rows([{ isLocked: true, trashedAt: null }]));

		await expect(documentsService.trash({ userId: "u1", type: "resume", id: "r1" })).rejects.toMatchObject({
			code: "RESUME_LOCKED",
			status: 403,
		});
		expect(dbMock.update).not.toHaveBeenCalled();
	});

	it("deletes for good only what is already in Trash", async () => {
		dbMock.select.mockReturnValueOnce(rows([{ isLocked: false, trashedAt: null }]));
		await expect(documentsService.purge({ userId: "u1", type: "resume", id: "r1" })).rejects.toMatchObject({
			code: "BAD_REQUEST",
		});

		dbMock.select.mockReturnValueOnce(rows([{ isLocked: false, trashedAt: new Date() }]));
		await documentsService.purge({ userId: "u1", type: "resume", id: "r1" });
		expect(resumeServiceMock.delete).toHaveBeenCalledWith({
			id: "r1",
			userId: "u1",
			trashedBefore: expect.any(Date),
		});
	});

	it("sends only the selected loaded resume IDs to the batch delete and reports skipped ones", async () => {
		resumeServiceMock.deleteTrashedMany.mockResolvedValueOnce(1);

		await expect(
			documentsService.purgeMany({
				userId: "u1",
				documents: [
					{ type: "resume", id: "r1" },
					{ type: "resume", id: "r2" },
				],
			}),
		).resolves.toEqual({ deleted: 1, skipped: 1 });
		expect(resumeServiceMock.deleteTrashedMany).toHaveBeenCalledWith({
			userId: "u1",
			ids: ["r1", "r2"],
			trashedBefore: expect.any(Date),
		});
	});

	it("propagates a failed batch delete so the caller can report it", async () => {
		resumeServiceMock.deleteTrashedMany.mockRejectedValueOnce(new Error("database unavailable"));

		await expect(
			documentsService.purgeMany({ userId: "u1", documents: [{ type: "resume", id: "r1" }] }),
		).rejects.toThrow("database unavailable");
	});
});

describe("copyForJob", () => {
	const source = {
		name: "Product Designer — Lumen",
		tags: ["design"],
		data: { metadata: { page: { locale: "en-US" } } },
	};

	it("links the copy to the job, and gives the job the copy when it has no resume", async () => {
		resumeServiceMock.getById.mockResolvedValueOnce(source);
		dbMock.select.mockReturnValueOnce(rows([{ id: "a1", company: "Orbital", resumeId: null }]));
		resumeServiceMock.create.mockResolvedValueOnce("copy");
		const set = updates();

		const id = await documentsService.copyForJob({ userId: "u1", resumeId: "r1", applicationId: "a1" });

		expect(id).toBe("copy");
		expect(resumeServiceMock.create).toHaveBeenCalledWith(
			expect.objectContaining({ name: "Product Designer — Orbital", tags: ["design"] }),
		);
		expect(set).toHaveBeenCalledWith({ applicationId: "a1" });
		expect(applicationServiceMock.update).toHaveBeenCalledWith({ userId: "u1", id: "a1", resumeId: "copy" });
	});

	it.each(["saved", "applied"])(
		"prepares a copy at %s while preserving its base and submitted documents",
		async (status) => {
			resumeServiceMock.getById.mockResolvedValueOnce(source);
			dbMock.select.mockReturnValueOnce(rows([{ id: "a1", company: "Orbital", resumeId: "base", status }]));
			resumeServiceMock.create.mockResolvedValueOnce("copy");
			const set = updates();

			await documentsService.copyForJob({ userId: "u1", resumeId: "r1", applicationId: "a1", name: "Mine" });

			expect(resumeServiceMock.create).toHaveBeenCalledWith(expect.objectContaining({ name: "Mine" }));
			expect(set).toHaveBeenCalledTimes(1);
			if (status === "saved")
				expect(applicationServiceMock.update).toHaveBeenCalledWith({ userId: "u1", id: "a1", resumeId: "copy" });
			else expect(applicationServiceMock.update).not.toHaveBeenCalled();
			expect(resumeServiceMock.create).toHaveBeenCalledWith(expect.objectContaining({ data: source.data }));
		},
	);
});

describe("linkApplication", () => {
	it.each([
		{ status: "saved", resumeId: null, sentResumeVersionId: null, selected: true },
		{ status: "saved", resumeId: "base", sentResumeVersionId: null, selected: true },
		{ status: "applied", resumeId: "submitted", sentResumeVersionId: "version", selected: false },
		{ status: "saved", resumeId: "submitted", sentResumeVersionId: "version", selected: false },
	])("links manual preparation while preserving submission history: %j", async ({ selected, ...application }) => {
		dbMock.select.mockReturnValueOnce(rows([{ isLocked: false, trashedAt: null }]));
		dbMock.select.mockReturnValueOnce(rows([{ id: "a1", company: "Orbital", ...application }]));
		const expectedUpdatedAt = new Date("2026-01-01T00:00:00Z");
		await expect(
			documentsService.linkApplication({
				userId: "u1",
				type: "resume",
				id: "new",
				applicationId: "a1",
				expectedUpdatedAt,
			}),
		).resolves.toMatchObject({ id: "new" });
		// The resume's own revision answers, so the open editor's next autosave builds on it.
		expect(writeResumeFieldsMock).toHaveBeenCalledWith(
			expect.objectContaining({ id: "new", set: { applicationId: "a1" }, expectedUpdatedAt }),
		);
		if (selected)
			expect(applicationServiceMock.update).toHaveBeenCalledWith({ userId: "u1", id: "a1", resumeId: "new" });
		else expect(applicationServiceMock.update).not.toHaveBeenCalled();
	});
});