import { describe, it, expect, beforeEach, vi } from "vitest"; // The mock state has to be hoisted to the top of the file because Vitest // hoists `vi.mock` factories above all imports. const { store, pbMock, clearStore } = vi.hoisted(() => { const store: Record>> = {}; let seq = 0; const nextId = () => `mock-${++seq}`; const getOrCreate = (collection: string) => { if (!store[collection]) store[collection] = new Map(); return store[collection]; }; const where = (collection: string, filter: string) => { const map = getOrCreate(collection); const items = Array.from(map.values()); if (!filter || !filter.trim()) return items; const clauses = filter.split("&&").map((c) => c.trim()); return items.filter((item) => clauses.every((clause) => { const m = clause.match(/^(\w+)\s*=\s*"?([^"]+)"?$/); if (!m) return true; const [, field, raw] = m; const value = raw.replace(/^"|"$/g, ""); if (field === "year" || field === "month") { return Number(item[field]) === Number(value); } return String(item[field] ?? "") === value; }) ); }; const pbMock = { collection: (name: string) => ({ async getList(page = 1, perPage = 25, opts: { filter?: string } = {}) { const items = where(name, opts.filter || ""); const start = (page - 1) * perPage; return { items: items.slice(start, start + perPage), totalItems: items.length, page, perPage, }; }, async getFullList(opts: { filter?: string; fields?: string } = {}) { return where(name, opts.filter || ""); }, async getFirstListItem(filter: string) { const items = where(name, filter); if (items.length === 0) { const err = new Error("not found") as Error & { status: number }; err.status = 404; throw err; } return items[0]; }, async getOne(id: string) { const item = getOrCreate(name).get(id); if (!item) { const err = new Error("not found") as Error & { status: number }; err.status = 404; throw err; } return item; }, async create(data: Record) { // Enforce the unique (year, month) index for quote_counters so the // service's race-handling path can be exercised. if (name === "quote_counters") { const map = getOrCreate(name); for (const item of map.values()) { if (item.year === data.year && item.month === data.month) { const err = new Error("unique constraint") as Error & { status: number }; err.status = 409; throw err; } } } const item = { id: nextId(), created: new Date().toISOString(), updated: new Date().toISOString(), ...data, }; getOrCreate(name).set(item.id, item); return item; }, async update(id: string, data: Record) { const map = getOrCreate(name); const existing = map.get(id); if (!existing) { const err = new Error("not found") as Error & { status: number }; err.status = 404; throw err; } for (const [key, value] of Object.entries(data)) { if (key.endsWith("+")) { const real = key.slice(0, -1); existing[real] = Number(existing[real] ?? 0) + Number(value); } else { existing[key] = value; } } existing.updated = new Date().toISOString(); // Return a clone so concurrent callers each see the value at the // moment their update ran, not the final mutated value. return { ...existing }; }, }), }; const clearStore = () => { for (const key of Object.keys(store)) delete store[key]; seq = 0; }; return { store, pbMock, clearStore }; }); vi.mock("@/lib/server/pocketbase-admin", () => ({ getAdminPocketBase: vi.fn().mockResolvedValue(pbMock), })); import { generateQuoteNumberServer, findOrCreateCustomer, findOrCreateCompany, createQuoteFromEmail, appendReplyToQuote, findQuoteByMessageId, extractQuoteNumberFromSubject, normalizeCompanyName, sendQuoteEmail, retryQuoteEmail, recordSendOutcome, } from "./quotes-service"; beforeEach(() => { clearStore(); }); describe("normalizeCompanyName", () => { it("lowercases, trims, collapses whitespace, strips trailing punctuation", () => { expect(normalizeCompanyName(" Acme Holdings. ")).toBe("acme"); }); it("strips common legal suffixes", () => { expect(normalizeCompanyName("Acme Pty Ltd")).toBe("acme"); expect(normalizeCompanyName("Acme Proprietary Limited")).toBe("acme"); expect(normalizeCompanyName("Acme Corp.")).toBe("acme"); expect(normalizeCompanyName("Acme Incorporated")).toBe("acme"); }); it("returns empty string for blank input", () => { expect(normalizeCompanyName("")).toBe(""); expect(normalizeCompanyName(" ")).toBe(""); }); }); describe("extractQuoteNumberFromSubject", () => { it("extracts Q-YYYY-MM-NNN from a fresh quote subject", () => { expect(extractQuoteNumberFromSubject("Quotation Q-2026-06-001")).toBe("Q-2026-06-001"); }); it("extracts from a reply subject (Re: prefix)", () => { expect(extractQuoteNumberFromSubject("Re: Quotation Q-2026-06-001")).toBe("Q-2026-06-001"); }); it("returns null when no quote number is present", () => { expect(extractQuoteNumberFromSubject("Just a normal email")).toBeNull(); expect(extractQuoteNumberFromSubject("Quote Q-26-6-1 (wrong format)")).toBeNull(); }); }); describe("generateQuoteNumberServer", () => { it("starts the month at 001", async () => { const n = await generateQuoteNumberServer(); const now = new Date(); const year = now.getFullYear(); const month = String(now.getMonth() + 1).padStart(2, "0"); expect(n).toBe(`Q${year}${month}001`); }); it("increments on each call", async () => { const a = await generateQuoteNumberServer(); const b = await generateQuoteNumberServer(); const c = await generateQuoteNumberServer(); const now = new Date(); const month = String(now.getMonth() + 1).padStart(2, "0"); const prefix = `Q${now.getFullYear()}${month}`; expect(a).toBe(`${prefix}001`); expect(b).toBe(`${prefix}002`); expect(c).toBe(`${prefix}003`); }); it("produces unique numbers under concurrent calls (no race)", async () => { const results = await Promise.all( Array.from({ length: 10 }, () => generateQuoteNumberServer()) ); const unique = new Set(results); expect(unique.size).toBe(10); const now = new Date(); const month = String(now.getMonth() + 1).padStart(2, "0"); const prefix = `Q${now.getFullYear()}${month}`; for (const n of results) { expect(n.startsWith(prefix)).toBe(true); } }); }); describe("findOrCreateCustomer", () => { it("finds an existing customer by exact email match", async () => { const existing = await pbMock.collection("customers").create({ customer: "Acme Mining", email: "buyer@acme.co.za", company: "Acme", }); const { customer, created } = await findOrCreateCustomer({ email: "buyer@acme.co.za", name: "Should Not Be Used", }); expect(created).toBe(false); expect(customer.id).toBe(existing.id); expect(customer.customer).toBe("Acme Mining"); }); it("finds by alternative_email when primary email misses", async () => { const existing = await pbMock.collection("customers").create({ customer: "Acme Mining", email: "primary@acme.co.za", alternative_email: "alt@acme.co.za", company: "Acme", }); const { customer, created } = await findOrCreateCustomer({ email: "alt@acme.co.za" }); expect(created).toBe(false); expect(customer.id).toBe(existing.id); }); it("finds by buyer_email when primary and alt miss", async () => { const existing = await pbMock.collection("customers").create({ customer: "Acme Mining", email: "primary@acme.co.za", buyer_email: "buyer@acme.co.za", company: "Acme", }); const { customer, created } = await findOrCreateCustomer({ email: "buyer@acme.co.za" }); expect(created).toBe(false); expect(customer.id).toBe(existing.id); }); it("creates a new customer when no match exists", async () => { // Pre-create the company record the hint refers to — `customer.company` // is now a relation, so the hint must resolve to a real company id // (or be left empty). const company = await pbMock.collection("companies").create({ company: "Unknown Co", address: "", vendor: "", }); const { customer, created } = await findOrCreateCustomer({ email: "new@unknown.co.za", name: "New Person", companyHint: "Unknown Co", }); expect(created).toBe(true); expect(customer.email).toBe("new@unknown.co.za"); expect(customer.customer).toBe("New Person"); expect(customer.company).toBe(company.id); expect(customer.description).toMatch(/Auto-created/); }); it("never fuzzy-merges on company name", async () => { // Two customers with similar emails from different domains should stay // separate. const a = await findOrCreateCustomer({ email: "john@acme.com" }); const b = await findOrCreateCustomer({ email: "jane@beta.com" }); expect(a.customer.id).not.toBe(b.customer.id); }); it("throws when email is missing", async () => { await expect(findOrCreateCustomer({ email: "" })).rejects.toThrow(/email is required/); }); }); describe("findOrCreateCompany", () => { it("finds an existing company by case-insensitive exact match", async () => { const existing = await pbMock.collection("companies").create({ company: "Acme Holdings", address: "1 Main Rd", vendor: "", }); const { company, created } = await findOrCreateCompany({ name: "acme holdings" }); expect(created).toBe(false); expect(company?.id).toBe(existing.id); }); it("finds by normalized match (stripped suffix)", async () => { const existing = await pbMock.collection("companies").create({ company: "Acme", address: "1 Main Rd", vendor: "", }); const { company, created } = await findOrCreateCompany({ name: "Acme Pty Ltd" }); expect(created).toBe(false); expect(company?.id).toBe(existing.id); }); it("creates a new company when no match", async () => { const { company, created } = await findOrCreateCompany({ name: "Brand New Co", address: "5 New St", }); expect(created).toBe(true); expect(company?.company).toBe("Brand New Co"); expect(company?.address).toBe("5 New St"); }); it("returns null company when name is blank", async () => { const { company, created } = await findOrCreateCompany({ name: "" }); expect(company).toBeNull(); expect(created).toBe(false); }); it("never fuzzy-merges on partial overlap", async () => { await pbMock.collection("companies").create({ company: "Acme Mining Supplies", address: "", vendor: "", }); const { created } = await findOrCreateCompany({ name: "Acme Tools" }); // "Acme" is shared but the full strings are different — must create. expect(created).toBe(true); }); }); describe("createQuoteFromEmail", () => { const basePayload = { from_email: "buyer@newco.co.za", from_name: "Buyer Person", subject: "RFQ: Mining equipment", body_plain: "Please quote on the following items.", message_id: "", in_reply_to: undefined as string | undefined, received_at: new Date().toISOString(), extracted_items: [ { description: "20mm cable ties (pack of 100)", quantity: 5, unit: "pack" }, { description: "Cable gland M20", quantity: 10, unit: "each" }, ], attachments: [ { filename: "rfq.pdf", content_type: "application/pdf", size: 1024, // 1 byte of base64 = "AA==" base64: "AA==", }, ], }; it("creates a new quote, customer, company, items, and attachments", async () => { const result = await createQuoteFromEmail({ ...basePayload, company_hint: "NewCo Mining", }); expect(result.deduped).toBe(false); expect(result.quote_number).toMatch(/^Q\d{4}\d{2}001$/); expect(result.items).toBe(2); // Attachments are no longer created in this path — the n8n flow calls // `attachments.upload_for_quote` once per file in a follow-up step, so // the create call must return 0 to avoid a 5 MB base64 POST that the // App Router rejects. The caller is responsible for the upload. expect(result.attachments).toBe(0); expect(result.customer.email).toBe("buyer@newco.co.za"); expect(result.company?.company).toBe("NewCo Mining"); expect(result.quote.email_sender).toBe("buyer@newco.co.za"); expect(result.quote.email_subject).toBe("RFQ: Mining equipment"); expect(result.quote.email_message_id).toBe(""); expect(result.quote.has_attachments).toBe(true); expect(result.quote.status).toBe("new"); expect(result.quote.notes).toBe(""); // not a notes blob }); it("creates AI-extracted items as drafts (is_processed=false, zero prices)", async () => { const result = await createQuoteFromEmail(basePayload); const items = await pbMock.collection("quote_items").getFullList({ filter: `quote = "${result.quote.id}"`, }); expect(items.length).toBe(2); for (const item of items) { expect(item.is_processed).toBe(false); // No fabricated cost or selling price. expect(Number(item.cost_price)).toBe(0); expect(Number(item.selling_price)).toBe(0); } }); it("dedupes by email_message_id — second call returns the same quote", async () => { const first = await createQuoteFromEmail(basePayload); const second = await createQuoteFromEmail(basePayload); expect(second.deduped).toBe(true); expect(second.quote.id).toBe(first.quote.id); expect(second.quote_number).toBe(first.quote_number); }); it("matches an existing customer by email (does not create duplicate)", async () => { const existing = await pbMock.collection("customers").create({ customer: "Existing Buyer", email: "buyer@newco.co.za", company: "Old Co", }); const result = await createQuoteFromEmail(basePayload); expect(result.customer.id).toBe(existing.id); }); it("uses company_hint from payload when provided", async () => { const result = await createQuoteFromEmail({ ...basePayload, company_hint: " Acme Pty Ltd ", }); expect(result.company?.company).toBe("Acme Pty Ltd"); }); it("leaves company null when no company_hint is provided (no subject fallback)", async () => { // The user explicitly does not want us to invent a company name from the // email subject — that's the kind of fabrication we're trying to avoid. // When the AI can't find a company in the body, the quoter picks it // in the form. const result = await createQuoteFromEmail({ ...basePayload, subject: "RFQ from Acme Mining", }); expect(result.company).toBeNull(); }); it("tolerates missing from_email, message_id, and subject (treats empty subject as a real value)", async () => { // The n8n Parse Email node stamps `(no subject)` when the inbound email // has no Subject header, so WFDASH receives a real string. The schema // invariant is "subject is a string", not "subject is non-empty" — // and even an empty string is now tolerated at runtime, because the // n8n side is contractually obligated to send a placeholder. await expect(createQuoteFromEmail({ ...basePayload, message_id: "" })).resolves.toBeTruthy(); await expect(createQuoteFromEmail({ ...basePayload, from_email: "" })).resolves.toBeTruthy(); await expect( createQuoteFromEmail({ ...basePayload, from_email: "", message_id: "" }) ).resolves.toBeTruthy(); // Empty subject is now tolerated (was hard-rejected before). The // office sees a placeholder quote in the queue. await expect(createQuoteFromEmail({ ...basePayload, subject: "" })).resolves.toBeTruthy(); // Whitespace-only subject is also tolerated — the description is stored // verbatim so a future regression that drops the Parse Email trim // doesn't take the whole pipeline down. await expect(createQuoteFromEmail({ ...basePayload, subject: " " })).resolves.toBeTruthy(); }); it("accepts a placeholder subject like '(no subject)' and stores it on the quote", async () => { // The n8n side stamps `(no subject)` for emails with no Subject header. // WFDASH must accept that literal string as a real subject, store it // verbatim on the quote, and create the row so the office sees it. const result = await createQuoteFromEmail({ ...basePayload, subject: "(no subject)", body_plain: "", extracted_items: [], }); expect(result.quote.description).toBe("(no subject)"); expect(result.quote.email_subject).toBe("(no subject)"); expect(result.items).toBe(0); }); it("placeholder subject + empty body + empty from_email all combine cleanly", async () => { // A fully-blank RFC 5321-violating send: no subject, no body, no From. // All three layers of tolerance combine: placeholder subject, no body, // sentinel "Unknown Sender" customer. The quote is created. const result = await createQuoteFromEmail({ from_email: "", from_name: "", subject: "(no subject)", body_plain: "", body_html: "", message_id: "", received_at: "2026-06-12T18:30:00.000Z", extracted_items: [], }); expect(result.customer.customer).toBe("Unknown Sender"); expect(result.customer.email).toBe("unknown-sender@no-from.wfdash.local"); expect(result.quote.description).toBe("(no subject)"); expect(result.quote.email_subject).toBe("(no subject)"); expect(result.quote.email_sender).toBe(""); expect(result.items).toBe(0); }); it("creates a quote with a sentinel 'Unknown Sender' customer when from_email is empty", async () => { const result = await createQuoteFromEmail({ ...basePayload, from_email: "" }); expect(result.deduped).toBe(false); expect(result.customer.customer).toBe("Unknown Sender"); expect(result.customer.email).toBe("unknown-sender@no-from.wfdash.local"); // The literal empty string is stored, not a placeholder — the sentinel // is only used for the `customer` relation. expect(result.quote.email_sender).toBe(""); }); it("treats whitespace-only from_email as missing", async () => { const result = await createQuoteFromEmail({ ...basePayload, from_email: " " }); expect(result.customer.customer).toBe("Unknown Sender"); expect(result.customer.email).toBe("unknown-sender@no-from.wfdash.local"); }); it("two emails with no from_email both link to the same sentinel customer", async () => { // Different subjects bypass the message_id dedup, so two distinct // quotes are created — but both should reuse the same sentinel. const r1 = await createQuoteFromEmail({ ...basePayload, from_email: "", subject: "Unknown sender email A", message_id: "", }); const r2 = await createQuoteFromEmail({ ...basePayload, from_email: "", subject: "Unknown sender email B", message_id: "", }); expect(r1.deduped).toBe(false); expect(r2.deduped).toBe(false); expect(r1.quote.id).not.toBe(r2.quote.id); expect(r1.customer.id).toBe(r2.customer.id); }); it("a real from_email still wins over the sentinel", async () => { const result = await createQuoteFromEmail({ ...basePayload, from_email: "real-buyer@somewhere.co.za", }); expect(result.customer.email).toBe("real-buyer@somewhere.co.za"); expect(result.customer.customer).not.toBe("Unknown Sender"); }); it("existing sentinel survives a fresh run (no duplicate Unknown Sender row)", async () => { // Pre-create the sentinel so the findOrCreate path hits the existing // branch. Verify no second customer is created. const customersBefore = await pbMock.collection("customers").getFullList(); await pbMock.collection("customers").create({ customer: "Unknown Sender", email: "unknown-sender@no-from.wfdash.local", company: "Unknown", description: "Pre-existing sentinel.", }); const customersAfter = await pbMock.collection("customers").getFullList(); expect(customersAfter.length).toBe(customersBefore.length + 1); const result = await createQuoteFromEmail({ ...basePayload, from_email: "" }); expect(result.customer.email).toBe("unknown-sender@no-from.wfdash.local"); expect(result.customer.description).toBe("Pre-existing sentinel."); const customersFinal = await pbMock.collection("customers").getFullList(); expect(customersFinal.length).toBe(customersAfter.length); }); it("synthesizes a stable message_id when the inbound email has no Message-ID header", async () => { // iCloud / Mail.app sometimes strip the Message-ID header. The pipeline // must still create the quote and dedup correctly on retry. const noId1 = await createQuoteFromEmail({ ...basePayload, message_id: "", }); const noId2 = await createQuoteFromEmail({ ...basePayload, message_id: "", }); expect(noId1.quote.email_message_id).toMatch(/^synth-[0-9a-f]{8}@wfdash\.local$/); expect(noId2.deduped).toBe(true); expect(noId2.quote.id).toBe(noId1.quote.id); }); it("treats whitespace-only message_id as missing and synthesizes", async () => { const result = await createQuoteFromEmail({ ...basePayload, message_id: " ", }); expect(result.quote.email_message_id).toMatch(/^synth-[0-9a-f]{8}@wfdash\.local$/); }); it("keeps a real (non-empty) message_id verbatim — never synthesizes over a real one", async () => { const result = await createQuoteFromEmail({ ...basePayload, message_id: "", }); expect(result.quote.email_message_id).toBe(""); }); }); describe("appendReplyToQuote", () => { it("matches by In-Reply-To header (strongest signal)", async () => { const created = await createQuoteFromEmail({ from_email: "buyer@a.com", from_name: "Buyer", subject: "Quotation needed", body_plain: "", message_id: "", }); const result = await appendReplyToQuote({ from_email: "buyer@a.com", from_name: "Buyer", subject: "Re: Some subject without a number", body_plain: "Thanks, looks good.", message_id: "", in_reply_to: "", received_at: new Date().toISOString(), }); expect(result.matched_by).toBe("in_reply_to"); expect(result.quote?.id).toBe(created.quote.id); expect((result.reply as Record).in_reply_to).toBe(""); }); it("falls back to subject regex when In-Reply-To is missing", async () => { const created = await createQuoteFromEmail({ from_email: "buyer@b.com", subject: "Need a quote", body_plain: "", message_id: "", }); const result = await appendReplyToQuote({ from_email: "buyer@b.com", subject: `Re: Quotation ${created.quote_number}`, body_plain: "OK, please proceed.", message_id: "", }); expect(result.matched_by).toBe("subject"); expect(result.quote?.id).toBe(created.quote.id); }); it("updates has_new_reply and last_reply_at on the matched quote", async () => { const created = await createQuoteFromEmail({ from_email: "buyer@c.com", subject: "Need a quote", body_plain: "", message_id: "", }); const replyDate = "2026-06-11T10:00:00.000Z"; await appendReplyToQuote({ from_email: "buyer@c.com", subject: `Re: Quotation ${created.quote_number}`, body_plain: "Approved.", message_id: "", received_at: replyDate, }); const updated = await pbMock.collection("quotes").getOne(created.quote.id); expect(updated.has_new_reply).toBe(true); expect(updated.last_reply_at).toBe(replyDate); }); it("returns matched_by='none' when no match — caller moves to Unmatched", async () => { const result = await appendReplyToQuote({ from_email: "unknown@x.com", subject: "Some random reply", body_plain: "Hello", }); expect(result.matched_by).toBe("none"); expect(result.quote).toBeNull(); expect(result.reply).toBeNull(); }); it("stores the reply as a structured quote_replies row, not as notes text", async () => { const created = await createQuoteFromEmail({ from_email: "buyer@d.com", subject: "Need a quote", body_plain: "", message_id: "", }); await appendReplyToQuote({ from_email: "buyer@d.com", subject: `Re: Quotation ${created.quote_number}`, body_plain: "Reply body content", quoted_text: "Original quoted text", message_id: "", }); const replies = await pbMock.collection("quote_replies").getFullList({ filter: `quote = "${created.quote.id}"`, }); expect(replies.length).toBe(1); expect(replies[0].body_plain).toBe("Reply body content"); expect(replies[0].quoted_text).toBe("Original quoted text"); // The quote's notes field should NOT contain the reply body. expect(created.quote.notes).toBe(""); }); }); describe("findQuoteByMessageId", () => { it("returns the matching quote", async () => { const created = await createQuoteFromEmail({ from_email: "buyer@e.com", subject: "Need a quote", body_plain: "", message_id: "", }); const found = await findQuoteByMessageId(""); expect(found?.id).toBe(created.quote.id); }); it("returns null when no match", async () => { const found = await findQuoteByMessageId(""); expect(found).toBeNull(); }); it("returns null for empty Message-ID", async () => { expect(await findQuoteByMessageId("")).toBeNull(); }); }); // ───────────────────────────────────────────────────────────────────────────── // Outbound send-email pipeline // ───────────────────────────────────────────────────────────────────────────── /** * Helper: create a quote in the requested status with a real-looking * customer + PDF already attached. The pipeline tests below mutate * this base case (delete the PDF, blank the email, etc.) to exercise * specific failure paths. */ async function seedReadyQuote(overrides: { status?: string; customerEmail?: string | null; customerName?: string; withPdf?: boolean; } = {}) { const customer = await pbMock.collection("customers").create({ customer: overrides.customerName ?? "Acme Mining", email: overrides.customerEmail === null ? "" : overrides.customerEmail ?? "buyer@acme.co.za", alternative_email: "", buyer_email: "", number: "", company: "Acme", dateadded: "", lastvisiteddate: "", rep: "", coordinates: "", description: "", }); const q = await pbMock.collection("quotes").create({ quote_number: "Q-2026-06-099", customer: customer.id, status: overrides.status ?? "approval_pending", notes: "", email_sender: "", email_subject: "", email_body: "", has_attachments: false, company_letterhead: "CNL", }); if (overrides.withPdf !== false) { await pbMock.collection("quote_attachments").create({ quote: q.id, filename: "quote.pdf", file: ["pdf-token"], content_type: "application/pdf", size_bytes: 12345, email_message_id: "", kind: "pdf", uploaded_at: new Date().toISOString(), }); } return { quote: q, customer }; } describe("sendQuoteEmail", () => { it("flips status to sending on a happy path and persists composition", async () => { const { quote } = await seedReadyQuote(); const result = await sendQuoteEmail(quote.id, { cc: "buyer2@acme.co.za, ceo@acme.co.za", bcc: "rep@wfdash.local", subject: "Re: Quote Q-2026-06-099", message: "Please find attached.", attachAuthLetters: true, selectedAttachmentIds: [], }); expect(result.failure).toBeNull(); expect(result.quote.status).toBe("sending"); expect(result.quote.email_cc).toBe("buyer2@acme.co.za, ceo@acme.co.za"); expect(result.quote.email_subject_outbound).toBe("Re: Quote Q-2026-06-099"); expect(result.quote.attach_auth_letters).toBe(true); expect(result.quote.sending_started_at).toBeTruthy(); expect(result.quote.email_error).toBe(""); }); it("captures selectedAttachmentIds into email_outbound_attachment_ids JSON, filters foreign IDs", async () => { const { quote } = await seedReadyQuote(); const a1 = await pbMock.collection("quote_attachments").create({ quote: quote.id, filename: "spec.pdf", file: ["t1"], content_type: "application/pdf", size_bytes: 1, email_message_id: "", kind: "doc", direction: "outbound", }); const a2 = await pbMock.collection("quote_attachments").create({ quote: quote.id, filename: "drawing.dwg", file: ["t2"], content_type: "application/octet-stream", size_bytes: 2, email_message_id: "", kind: "other", direction: "outbound", }); // Belongs to a DIFFERENT quote — must be filtered out. const a3 = await pbMock.collection("quote_attachments").create({ quote: "DIFFERENT_QUOTE_ID", filename: "smuggled.pdf", file: ["t3"], content_type: "application/pdf", size_bytes: 3, email_message_id: "", kind: "doc", }); const result = await sendQuoteEmail(quote.id, { cc: "", bcc: "", subject: "", message: "", attachAuthLetters: false, selectedAttachmentIds: [a1.id, a2.id, a3.id], }); expect(result.failure).toBeNull(); const parsed = JSON.parse(result.quote.email_outbound_attachment_ids); expect(parsed.sort()).toEqual([a1.id, a2.id].sort()); expect(parsed).not.toContain(a3.id); }); it("rejects with no_recipient when customer has no email and no alternative", async () => { const { quote } = await seedReadyQuote({ customerEmail: "" }); const result = await sendQuoteEmail(quote.id, { cc: "", bcc: "", subject: "", message: "", attachAuthLetters: true, selectedAttachmentIds: [], }); expect(result.failure?.code).toBe("no_recipient"); expect(result.quote.status).toBe("mail_failed"); expect(result.quote.email_error).toMatch(/No valid recipient/); expect(result.quote.email_failed_at).toBeTruthy(); }); it("rejects with placeholder_customer when customer is the Unknown Sender sentinel", async () => { const sentinel = await pbMock.collection("customers").create({ id: "dcpb38w4mk6vrm5", customer: "Unknown Sender", email: "buyer@x.com", alternative_email: "", buyer_email: "", number: "", company: "", dateadded: "", lastvisiteddate: "", rep: "", coordinates: "", description: "", }); const q = await pbMock.collection("quotes").create({ quote_number: "Q-2026-06-100", customer: sentinel.id, status: "approval_pending", }); const result = await sendQuoteEmail(q.id, { cc: "", bcc: "", subject: "", message: "", attachAuthLetters: false, selectedAttachmentIds: [], }); expect(result.failure?.code).toBe("placeholder_customer"); expect(result.quote.status).toBe("mail_failed"); }); it("rejects with invalid_recipient when CC contains garbage", async () => { const { quote } = await seedReadyQuote(); const result = await sendQuoteEmail(quote.id, { cc: "good@x.com, not-an-email, also-bad", bcc: "", subject: "", message: "", attachAuthLetters: true, selectedAttachmentIds: [], }); expect(result.failure?.code).toBe("invalid_recipient"); expect(result.failure?.message).toContain("not-an-email"); expect(result.quote.status).toBe("mail_failed"); }); it("rejects with no_pdf when no PDF attachment exists", async () => { const { quote } = await seedReadyQuote({ withPdf: false }); const result = await sendQuoteEmail(quote.id, { cc: "", bcc: "", subject: "", message: "", attachAuthLetters: true, selectedAttachmentIds: [], }); expect(result.failure?.code).toBe("no_pdf"); expect(result.quote.status).toBe("mail_failed"); }); it("rejects with invalid_status when quote is already emailed", async () => { const { quote } = await seedReadyQuote({ status: "emailed" }); const result = await sendQuoteEmail(quote.id, { cc: "", bcc: "", subject: "", message: "", attachAuthLetters: true, selectedAttachmentIds: [], }); expect(result.failure?.code).toBe("invalid_status"); expect(result.quote.status).toBe("mail_failed"); }); it("returns quote_not_found for a bogus id", async () => { const result = await sendQuoteEmail("does-not-exist", { cc: "", bcc: "", subject: "", message: "", attachAuthLetters: true, selectedAttachmentIds: [], }); expect(result.failure?.code).toBe("quote_not_found"); }); }); describe("retryQuoteEmail", () => { it("flips a mail_failed quote back to sending and clears error", async () => { const { quote } = await seedReadyQuote({ status: "mail_failed" }); await pbMock.collection("quotes").update(quote.id, { email_error: "[smtp] Connection refused", email_failed_at: "2026-06-23T10:00:00.000Z", }); const result = await retryQuoteEmail(quote.id); expect(result.failure).toBeNull(); expect(result.quote.status).toBe("sending"); expect(result.quote.email_error).toBe(""); expect(result.quote.email_failed_at).toBe(""); expect(result.quote.sending_started_at).toBeTruthy(); }); it("rejects with invalid_status when the quote isn't mail_failed", async () => { const { quote } = await seedReadyQuote({ status: "approval_pending" }); const result = await retryQuoteEmail(quote.id); expect(result.failure?.code).toBe("invalid_status"); }); it("rejects with quote_not_found for a bogus id", async () => { const result = await retryQuoteEmail("missing"); expect(result.failure?.code).toBe("quote_not_found"); }); }); describe("recordSendOutcome", () => { it("flips to emailed on success + stamps message_id + clears error", async () => { const { quote } = await seedReadyQuote({ status: "sending" }); await pbMock.collection("quotes").update(quote.id, { sending_started_at: new Date().toISOString(), }); const updated = await recordSendOutcome({ quoteId: quote.id, outcome: "success", messageId: "", }); expect(updated.status).toBe("emailed"); expect(updated.email_delivered).toBe(true); expect(updated.email_delivered_at).toBeTruthy(); expect(updated.email_outbound_message_id).toBe(""); expect(updated.email_error).toBe(""); expect(updated.sending_started_at).toBe(""); }); it("flips to mail_failed on SMTP failure + records reason + clears sending_started_at", async () => { const { quote } = await seedReadyQuote({ status: "sending" }); await pbMock.collection("quotes").update(quote.id, { sending_started_at: new Date().toISOString(), }); const updated = await recordSendOutcome({ quoteId: quote.id, outcome: "failure", errorMessage: "550 5.1.1 User unknown", messageId: "", }); expect(updated.status).toBe("mail_failed"); expect(updated.email_failed_at).toBeTruthy(); expect(updated.email_error).toMatch(/550 5\.1\.1 User unknown/); expect(updated.email_outbound_message_id).toBe(""); expect(updated.sending_started_at).toBe(""); }); it("truncates long error messages so we don't exceed PB's 5000-byte cap", async () => { const { quote } = await seedReadyQuote({ status: "sending" }); const huge = "x".repeat(10_000); const updated = await recordSendOutcome({ quoteId: quote.id, outcome: "failure", errorMessage: huge, }); expect(updated.email_error.length).toBeLessThan(5000); }); });