@chainlesschain/personal-data-hub 0.1.0

package/__tests__/adapters/email-imap-session.test.js

@@ -0,0 +1,334 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  ImapSession,
+  ImapAuthFailedError,
+  ImapConnectionFailedError,
+  ImapMailboxNotFoundError,
+} = require("../../lib/adapters/email-imap/imap-session");
+
+function makeFakeFactory({
+  connectThrows = null,
+  mailboxThrows = null,
+  fetchRows = [],
+  mailboxInfo = { uidValidity: 1, uidNext: 100, exists: 0 },
+} = {}) {
+  return function FakeImapFlow(_opts) {
+    return {
+      connect: async () => {
+        if (connectThrows) throw connectThrows;
+      },
+      mailboxOpen: async (name) => {
+        if (mailboxThrows) throw mailboxThrows;
+        return { path: name, name, ...mailboxInfo };
+      },
+      list: async () => [
+        { name: "INBOX", path: "INBOX", flags: [], specialUse: null },
+        { name: "Sent", path: "Sent", flags: [], specialUse: "\\Sent" },
+      ],
+      fetch: function () {
+        const rows = fetchRows.slice();
+        let i = 0;
+        return {
+          [Symbol.asyncIterator]() {
+            return {
+              next: async () =>
+                i < rows.length
+                  ? { value: rows[i++], done: false }
+                  : { value: undefined, done: true },
+            };
+          },
+        };
+      },
+      logout: async () => {},
+      close: async () => {},
+    };
+  };
+}
+
+describe("ImapSession construction", () => {
+  it("rejects missing required opts", () => {
+    expect(() => new ImapSession()).toThrow();
+    expect(() => new ImapSession({})).toThrow(/host/);
+    expect(() => new ImapSession({ host: "x", port: 993, user: "u" })).toThrow(/authCode/);
+    expect(() => new ImapSession({ host: "x", port: 993, authCode: "z" })).toThrow(/user/);
+  });
+
+  it("constructs cleanly with required opts", () => {
+    const s = new ImapSession({
+      host: "imap.test", port: 993, secure: true, user: "u@test.com", authCode: "abc",
+    });
+    expect(s.host).toBe("imap.test");
+    expect(s.port).toBe(993);
+    expect(s.secure).toBe(true);
+  });
+
+  it("defaults secure=true when not specified", () => {
+    const s = new ImapSession({ host: "x", port: 993, user: "u@t", authCode: "z" });
+    expect(s.secure).toBe(true);
+  });
+});
+
+describe("ImapSession.connect", () => {
+  it("connects successfully with injected factory", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory(),
+    });
+    await expect(s.connect()).resolves.toBeUndefined();
+  });
+
+  it("classifies auth failure as ImapAuthFailedError", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({
+        connectThrows: new Error("Authentication failed - invalid credentials"),
+      }),
+    });
+    await expect(s.connect()).rejects.toBeInstanceOf(ImapAuthFailedError);
+  });
+
+  it("classifies generic network errors as ImapConnectionFailedError", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({
+        connectThrows: new Error("ECONNREFUSED"),
+      }),
+    });
+    await expect(s.connect()).rejects.toBeInstanceOf(ImapConnectionFailedError);
+  });
+
+  it("enforces connectTimeoutMs", async () => {
+    function slowFactory() {
+      return {
+        connect: () => new Promise(() => {}),
+        close: async () => {},
+      };
+    }
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      connectTimeoutMs: 50,
+      imapFlowFactory: slowFactory,
+    });
+    await expect(s.connect()).rejects.toThrow(/timed out/);
+  });
+
+  it("requires connect() before openMailbox", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory(),
+    });
+    await expect(s.openMailbox("INBOX")).rejects.toThrow(/not connected/);
+  });
+});
+
+describe("ImapSession.openMailbox", () => {
+  it("returns uidValidity / uidNext / exists snapshot", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({
+        mailboxInfo: { uidValidity: 42, uidNext: 200, exists: 150 },
+      }),
+    });
+    await s.connect();
+    const r = await s.openMailbox("INBOX");
+    expect(r.uidValidity).toBe(42);
+    expect(r.uidNext).toBe(200);
+    expect(r.exists).toBe(150);
+  });
+
+  it("converts 'not found' messages to ImapMailboxNotFoundError", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({
+        mailboxThrows: new Error("Mailbox doesn't exist: NoSuch"),
+      }),
+    });
+    await s.connect();
+    await expect(s.openMailbox("NoSuch")).rejects.toBeInstanceOf(ImapMailboxNotFoundError);
+  });
+
+  it("rejects non-string mailbox name", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory(),
+    });
+    await s.connect();
+    await expect(s.openMailbox("")).rejects.toThrow(/non-empty string/);
+  });
+});
+
+describe("ImapSession.listMailboxes", () => {
+  it("returns name / path / flags / specialUse", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory(),
+    });
+    await s.connect();
+    const list = await s.listMailboxes();
+    expect(list).toHaveLength(2);
+    expect(list[0].name).toBe("INBOX");
+    expect(list[1].specialUse).toBe("\\Sent");
+  });
+});
+
+describe("ImapSession.fetchEnvelopesSince", () => {
+  it("yields normalized envelope rows", async () => {
+    const fakeRow = {
+      uid: 42,
+      internalDate: new Date("2026-04-01T10:00:00Z"),
+      flags: new Set(["\\Seen"]),
+      size: 1234,
+      envelope: {
+        messageId: "<msg-1@example.com>",
+        subject: "Hello",
+        from: [{ name: "Alice", address: "alice@example.com" }],
+        to: [{ name: "Me", address: "me@example.com" }],
+        cc: [],
+        date: new Date("2026-04-01T10:00:00Z"),
+      },
+    };
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({ fetchRows: [fakeRow] }),
+    });
+    await s.connect();
+    await s.openMailbox("INBOX");
+    const got = [];
+    for await (const env of s.fetchEnvelopesSince(0)) got.push(env);
+    expect(got).toHaveLength(1);
+    expect(got[0].uid).toBe(42);
+    expect(got[0].subject).toBe("Hello");
+    expect(got[0].messageId).toBe("<msg-1@example.com>");
+    expect(got[0].from[0].address).toBe("alice@example.com");
+    expect(got[0].flags).toEqual(["\\Seen"]);
+    expect(got[0].size).toBe(1234);
+    expect(got[0].internalDate).toBeInstanceOf(Date);
+  });
+
+  it("emits empty for an empty mailbox", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({ fetchRows: [] }),
+    });
+    await s.connect();
+    await s.openMailbox("INBOX");
+    const got = [];
+    for await (const env of s.fetchEnvelopesSince(0)) got.push(env);
+    expect(got).toEqual([]);
+  });
+
+  it("preserves order from underlying iterator", async () => {
+    const rows = [10, 20, 30].map((uid) => ({
+      uid,
+      internalDate: new Date(),
+      flags: [],
+      size: 0,
+      envelope: { messageId: `<m-${uid}@x>`, subject: `s${uid}`, from: [], to: [], cc: [], date: new Date() },
+    }));
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({ fetchRows: rows }),
+    });
+    await s.connect();
+    await s.openMailbox("INBOX");
+    const uids = [];
+    for await (const env of s.fetchEnvelopesSince(0)) uids.push(env.uid);
+    expect(uids).toEqual([10, 20, 30]);
+  });
+});
+
+describe("ImapSession.fetchFullSince", () => {
+  it("yields source bytes alongside envelope", async () => {
+    const raw = Buffer.from("RAW RFC822 SOURCE BYTES", "utf8");
+    const fakeRow = {
+      uid: 100,
+      internalDate: new Date(),
+      flags: [],
+      size: raw.length,
+      source: raw,
+      envelope: {
+        messageId: "<m@x>",
+        subject: "s",
+        from: [{ name: "A", address: "a@b" }],
+        to: [],
+        cc: [],
+        date: new Date(),
+      },
+    };
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({ fetchRows: [fakeRow] }),
+    });
+    await s.connect();
+    await s.openMailbox("INBOX");
+    const got = [];
+    for await (const row of s.fetchFullSince(0)) got.push(row);
+    expect(got).toHaveLength(1);
+    expect(Buffer.isBuffer(got[0].source)).toBe(true);
+    expect(got[0].source.toString()).toBe("RAW RFC822 SOURCE BYTES");
+    expect(got[0].uid).toBe(100);
+    expect(got[0].subject).toBe("s");
+  });
+
+  it("emits empty Buffer when server returns no source", async () => {
+    const fakeRow = {
+      uid: 1,
+      internalDate: new Date(),
+      flags: [],
+      size: 0,
+      // no `source` field
+      envelope: { messageId: "<m@x>", subject: "", from: [], to: [], cc: [], date: new Date() },
+    };
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory({ fetchRows: [fakeRow] }),
+    });
+    await s.connect();
+    await s.openMailbox("INBOX");
+    const got = [];
+    for await (const row of s.fetchFullSince(0)) got.push(row);
+    expect(Buffer.isBuffer(got[0].source)).toBe(true);
+    expect(got[0].source.length).toBe(0);
+  });
+});
+
+describe("ImapSession.close", () => {
+  it("is idempotent on never-connected session", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory(),
+    });
+    await expect(s.close()).resolves.toBeUndefined();
+  });
+
+  it("clears client reference so post-close calls fail clean", async () => {
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: makeFakeFactory(),
+    });
+    await s.connect();
+    await s.close();
+    await expect(s.openMailbox("INBOX")).rejects.toThrow(/not connected/);
+  });
+
+  it("doesn't fail when underlying logout throws", async () => {
+    let logoutCalled = false;
+    function factory() {
+      return {
+        connect: async () => {},
+        logout: async () => { logoutCalled = true; throw new Error("conn already dead"); },
+        close: async () => {},
+      };
+    }
+    const s = new ImapSession({
+      host: "x", port: 993, user: "u@t", authCode: "z",
+      imapFlowFactory: factory,
+    });
+    await s.connect();
+    await expect(s.close()).resolves.toBeUndefined();
+    expect(logoutCalled).toBe(true);
+  });
+});

package/__tests__/adapters/email-parser.test.js

@@ -0,0 +1,244 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const { parseRawEmail } = require("../../lib/adapters/email-imap/email-parser");
+
+// ─── Fixture builders ───────────────────────────────────────────────────
+
+function plaintextEmail({
+  from = "alice@example.com",
+  to = "bob@example.com",
+  subject = "Hello",
+  body = "Hello, world!",
+  date = "Fri, 19 May 2026 10:00:00 +0800",
+  messageId = "<m-1@example.com>",
+} = {}) {
+  return [
+    `From: ${from}`,
+    `To: ${to}`,
+    `Subject: ${subject}`,
+    `Date: ${date}`,
+    `Message-ID: ${messageId}`,
+    `Content-Type: text/plain; charset=utf-8`,
+    `Content-Transfer-Encoding: 7bit`,
+    ``,
+    body,
+  ].join("\r\n");
+}
+
+function multipartAlternative({ text = "plain version", html = "<p>html <b>version</b></p>" } = {}) {
+  const boundary = "BOUNDARY_42";
+  return [
+    `From: sender@example.com`,
+    `To: me@example.com`,
+    `Subject: Multipart`,
+    `MIME-Version: 1.0`,
+    `Content-Type: multipart/alternative; boundary="${boundary}"`,
+    ``,
+    `--${boundary}`,
+    `Content-Type: text/plain; charset=utf-8`,
+    ``,
+    text,
+    `--${boundary}`,
+    `Content-Type: text/html; charset=utf-8`,
+    ``,
+    html,
+    `--${boundary}--`,
+  ].join("\r\n");
+}
+
+function multipartWithAttachment({ filename = "report.pdf", contentType = "application/pdf", body = "%PDF-1.4\n/Encrypt placeholder\n" } = {}) {
+  const boundary = "MIXED_99";
+  const b64 = Buffer.from(body).toString("base64");
+  return [
+    `From: bank@example.com`,
+    `To: me@example.com`,
+    `Subject: Your statement`,
+    `MIME-Version: 1.0`,
+    `Content-Type: multipart/mixed; boundary="${boundary}"`,
+    ``,
+    `--${boundary}`,
+    `Content-Type: text/plain`,
+    ``,
+    `See attached statement.`,
+    `--${boundary}`,
+    `Content-Type: ${contentType}; name="${filename}"`,
+    `Content-Disposition: attachment; filename="${filename}"`,
+    `Content-Transfer-Encoding: base64`,
+    ``,
+    b64,
+    `--${boundary}--`,
+  ].join("\r\n");
+}
+
+// ─── parseRawEmail ──────────────────────────────────────────────────────
+
+describe("parseRawEmail — basic shape", () => {
+  it("rejects null/missing input", async () => {
+    await expect(parseRawEmail(null)).rejects.toThrow(/required/);
+    await expect(parseRawEmail()).rejects.toThrow(/required/);
+  });
+
+  it("accepts a Buffer", async () => {
+    const buf = Buffer.from(plaintextEmail(), "utf8");
+    const r = await parseRawEmail(buf);
+    expect(r.subject).toBe("Hello");
+    expect(r.textBody).toContain("Hello, world!");
+  });
+
+  it("accepts a string", async () => {
+    const r = await parseRawEmail(plaintextEmail());
+    expect(r.subject).toBe("Hello");
+  });
+
+  it("returns sourceBytes + contentSha256", async () => {
+    const raw = plaintextEmail();
+    const r = await parseRawEmail(raw);
+    expect(r.sourceBytes).toBe(Buffer.byteLength(raw));
+    expect(r.contentSha256).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  it("flattens headers to lowercased-keyed object", async () => {
+    const r = await parseRawEmail(plaintextEmail());
+    expect(r.headers["subject"]).toBe("Hello");
+    expect(r.headers["from"]).toBeDefined();
+    expect(r.headers["message-id"]).toBe("<m-1@example.com>");
+  });
+
+  it("parses Date header", async () => {
+    const r = await parseRawEmail(plaintextEmail());
+    expect(r.date).toBeInstanceOf(Date);
+    expect(r.date.getUTCFullYear()).toBe(2026);
+  });
+});
+
+describe("parseRawEmail — multipart", () => {
+  it("multipart/alternative yields both text + html bodies", async () => {
+    const r = await parseRawEmail(multipartAlternative());
+    expect(r.textBody).toContain("plain version");
+    expect(r.htmlBody).toContain("html");
+    expect(r.htmlBody).toContain("version");
+  });
+
+  it("multipart/mixed with attachment yields attachment metadata", async () => {
+    const r = await parseRawEmail(multipartWithAttachment());
+    expect(r.attachments).toHaveLength(1);
+    const a = r.attachments[0];
+    expect(a.filename).toBe("report.pdf");
+    expect(a.contentType).toContain("pdf");
+    expect(a.size).toBeGreaterThan(0);
+    expect(a.sha256).toMatch(/^[0-9a-f]{64}$/);
+    expect(a.contentDisposition).toBe("attachment");
+    expect(a.isInline).toBe(false);
+  });
+
+  it("flags encrypted PDFs heuristically (/Encrypt header in body)", async () => {
+    const r = await parseRawEmail(multipartWithAttachment({
+      filename: "encrypted.pdf",
+      body: "%PDF-1.4\n%fake header\n/Encrypt <<\n/V 4\n>>\n",
+    }));
+    expect(r.attachments[0].isEncrypted).toBe(true);
+  });
+
+  it("doesn't flag plaintext PDFs as encrypted", async () => {
+    const r = await parseRawEmail(multipartWithAttachment({
+      body: "%PDF-1.4\nplain content no encrypt token\n",
+    }));
+    expect(r.attachments[0].isEncrypted).toBe(false);
+  });
+
+  it("attachment buffer is omitted by default", async () => {
+    const r = await parseRawEmail(multipartWithAttachment());
+    expect(r.attachments[0].buffer).toBeUndefined();
+  });
+
+  it("keepAttachmentBuffers:true attaches the decoded buffer", async () => {
+    const r = await parseRawEmail(multipartWithAttachment(), { keepAttachmentBuffers: true });
+    expect(Buffer.isBuffer(r.attachments[0].buffer)).toBe(true);
+    expect(r.attachments[0].buffer.toString()).toContain("%PDF-1.4");
+  });
+});
+
+describe("parseRawEmail — encoding handling", () => {
+  it("decodes UTF-8 body correctly", async () => {
+    const utf8Body = "妈妈生日蛋白粉 ¥288.50";
+    const r = await parseRawEmail(plaintextEmail({ body: utf8Body }));
+    expect(r.textBody).toContain("妈妈生日蛋白粉");
+    expect(r.textBody).toContain("¥288.50");
+  });
+
+  it("decodes GBK-encoded body (via Content-Type charset)", async () => {
+    // Build raw bytes: header in UTF-8, body in GBK.
+    const headerAscii =
+      `From: sender@example.com\r\n` +
+      `To: me@example.com\r\n` +
+      `Subject: 中文\r\n` +
+      `MIME-Version: 1.0\r\n` +
+      `Content-Type: text/plain; charset=GBK\r\n\r\n`;
+    // GBK bytes for "妈妈生日": dc e8 dc e8 c9 fa c8 d5
+    const gbkBody = Buffer.from([0xc2, 0xe8, 0xc2, 0xe8, 0xc9, 0xfa, 0xc8, 0xd5]);
+    const raw = Buffer.concat([Buffer.from(headerAscii, "ascii"), gbkBody]);
+    const r = await parseRawEmail(raw);
+    // mailparser+iconv-lite converts GBK to UTF-8. We can't assert exact
+    // unicode without locking in iconv tables, but we can verify the
+    // body is non-empty + got past the GBK byte sequence (which is
+    // invalid UTF-8 — would error if left as raw).
+    expect(r.textBody.length).toBeGreaterThan(0);
+    expect(r.headers["content-type"]).toBeDefined();
+  });
+
+  it("RFC 2047 encoded subject is decoded", async () => {
+    const raw = [
+      `From: alice@example.com`,
+      `To: me@example.com`,
+      // =?UTF-8?B?5aaI5aaIc/eIuOWlh+aBpQ==?= (just a sample base64)
+      `Subject: =?UTF-8?B?5aaI5aaI?=`,
+      `Date: Fri, 19 May 2026 10:00:00 +0800`,
+      `Message-ID: <m@x>`,
+      `Content-Type: text/plain; charset=utf-8`,
+      ``,
+      `body`,
+    ].join("\r\n");
+    const r = await parseRawEmail(raw);
+    expect(r.subject).toBe("妈妈");
+  });
+});
+
+describe("parseRawEmail — truncation + edge cases", () => {
+  it("truncates bodies longer than maxBodyChars", async () => {
+    const longBody = "X".repeat(500_000);
+    const r = await parseRawEmail(plaintextEmail({ body: longBody }), { maxBodyChars: 1000 });
+    expect(r.textBody.length).toBeLessThan(longBody.length);
+    expect(r.textBody).toMatch(/truncated/);
+  });
+
+  it("returns empty bodies for emails with no payload", async () => {
+    const raw = [
+      `From: x@x.com`,
+      `To: y@y.com`,
+      `Subject: empty`,
+      `Date: Fri, 19 May 2026 10:00:00 +0800`,
+      `Message-ID: <m@x>`,
+      ``,
+      ``,
+    ].join("\r\n");
+    const r = await parseRawEmail(raw);
+    expect(r.textBody).toBe("");
+    expect(r.htmlBody).toBe("");
+    expect(r.attachments).toEqual([]);
+  });
+
+  it("contentSha256 is deterministic for identical input", async () => {
+    const raw = plaintextEmail();
+    const r1 = await parseRawEmail(raw);
+    const r2 = await parseRawEmail(raw);
+    expect(r1.contentSha256).toBe(r2.contentSha256);
+  });
+
+  it("contentSha256 differs across different inputs", async () => {
+    const r1 = await parseRawEmail(plaintextEmail({ body: "v1" }));
+    const r2 = await parseRawEmail(plaintextEmail({ body: "v2" }));
+    expect(r1.contentSha256).not.toBe(r2.contentSha256);
+  });
+});

package/__tests__/adapters/email-providers.test.js

@@ -0,0 +1,84 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  PROVIDERS,
+  resolveProvider,
+} = require("../../lib/adapters/email-imap/providers");
+
+describe("EMAIL_PROVIDERS preset table", () => {
+  it("exposes qq / 189 / 163 / outlook / gmail", () => {
+    expect(PROVIDERS.qq.host).toBe("imap.qq.com");
+    expect(PROVIDERS["189"].host).toBe("imap.189.cn");
+    expect(PROVIDERS["163"].host).toBe("imap.163.com");
+    expect(PROVIDERS.outlook.host).toBe("outlook.office365.com");
+    expect(PROVIDERS.gmail.host).toBe("imap.gmail.com");
+  });
+
+  it("every preset uses port 993 + TLS by default", () => {
+    for (const p of Object.values(PROVIDERS)) {
+      expect(p.port).toBe(993);
+      expect(p.secure).toBe(true);
+    }
+  });
+
+  it("each preset advertises an authNote pointing at authorization-code, not password", () => {
+    for (const p of Object.values(PROVIDERS)) {
+      expect(p.authNote.length).toBeGreaterThan(10);
+    }
+    expect(PROVIDERS.qq.authNote).toMatch(/授权码|auth.*code|app password/i);
+  });
+});
+
+describe("resolveProvider", () => {
+  it("returns preset config when no overrides", () => {
+    const r = resolveProvider({ provider: "qq" });
+    expect(r.host).toBe("imap.qq.com");
+    expect(r.port).toBe(993);
+    expect(r.secure).toBe(true);
+    expect(r.folders).toEqual(["INBOX", "Sent Messages"]);
+    expect(r.providerId).toBe("qq");
+  });
+
+  it("respects user overrides", () => {
+    const r = resolveProvider({
+      provider: "qq",
+      host: "imap.example.com",
+      port: 143,
+      secure: false,
+      folders: ["INBOX", "Drafts", "Custom"],
+      displayName: "My Mailbox",
+    });
+    expect(r.host).toBe("imap.example.com");
+    expect(r.port).toBe(143);
+    expect(r.secure).toBe(false);
+    expect(r.folders).toEqual(["INBOX", "Drafts", "Custom"]);
+    expect(r.displayName).toBe("My Mailbox");
+  });
+
+  it("rejects unknown provider", () => {
+    expect(() => resolveProvider({ provider: "myproto" })).toThrow(/unknown provider/i);
+  });
+
+  it("custom provider requires host", () => {
+    expect(() => resolveProvider({ provider: "custom" })).toThrow(/host/);
+  });
+
+  it("custom provider applies sensible defaults", () => {
+    const r = resolveProvider({
+      provider: "custom",
+      host: "mail.acme.test",
+    });
+    expect(r.host).toBe("mail.acme.test");
+    expect(r.port).toBe(993);
+    expect(r.secure).toBe(true);
+    expect(r.folders).toEqual(["INBOX"]);
+    expect(r.providerId).toBe("custom");
+  });
+
+  it("rejects null / wrong-type account", () => {
+    expect(() => resolveProvider()).toThrow();
+    expect(() => resolveProvider(null)).toThrow();
+  });
+});