@chainlesschain/personal-data-hub 0.4.29 → 0.4.31

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

@@ -1,347 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const {
-  CATEGORIES,
-  ALL_CATEGORIES,
-  classifyLayer1,
-  classifyLayer2,
-  classifyEmail,
-  parseLayer2Response,
-} = require("../../lib/adapters/email-imap/classifier");
-const { MockLLMClient } = require("../../lib/llm-client");
-
-const email = (overrides = {}) => ({
-  from: [{ name: "Someone", address: "user@example.com" }],
-  subject: "Hello",
-  textBody: "",
-  htmlBody: "",
-  attachments: [],
-  headers: {},
-  indicatorHeaders: {},
-  ...overrides,
-});
-
-// ─── Layer 1 ─────────────────────────────────────────────────────────────
-
-describe("Layer 1 — bank statements", () => {
-  it("招商银行 from-domain + 对账单 subject → bill_bank with high confidence", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "ebank@cmbchina.com" }],
-      subject: "招商银行信用卡 11 月对账单",
-    }));
-    expect(r.category).toBe(CATEGORIES.BILL_BANK);
-    expect(r.confidence).toBeGreaterThanOrEqual(0.92);
-    expect(r.ruleName).toContain("bill_bank");
-  });
-
-  it("中国银行 from-domain alone (no subject keyword) → bill_bank confidence ~0.9", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "noreply@bochk.cn" }],
-      subject: "您的账户更新",
-    }));
-    expect(r.category).toBe(CATEGORIES.BILL_BANK);
-    expect(r.confidence).toBeGreaterThanOrEqual(0.85);
-  });
-
-  it("ICBC from-domain → bill_bank", () => {
-    const r = classifyLayer1(email({ from: [{ address: "ebanking@icbc.com.cn" }] }));
-    expect(r.category).toBe(CATEGORIES.BILL_BANK);
-  });
-
-  it("credit-card subject keyword overrides generic bill_bank", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "card@cmbchina.com" }],
-      subject: "信用卡 11 月对账单",
-    }));
-    // bill_bank.cn-bank-major fires at 0.95, bill_credit at 0.92 — bank
-    // wins on confidence. The point is BOTH match; we don't break.
-    expect([CATEGORIES.BILL_BANK, CATEGORIES.BILL_CREDIT]).toContain(r.category);
-    expect(r.confidence).toBeGreaterThanOrEqual(0.9);
-  });
-
-  it("subject 信用卡账单 alone (no bank domain) → bill_credit", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "noreply@somerandombank.example" }],
-      subject: "您的信用卡账单已生成",
-    }));
-    expect(r.category).toBe(CATEGORIES.BILL_CREDIT);
-  });
-});
-
-describe("Layer 1 — e-commerce orders", () => {
-  it("淘宝 + 订单 → order high confidence", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "service@taobao.com" }],
-      subject: "您的订单 1234567 已发货",
-    }));
-    expect(r.category).toBe(CATEGORIES.ORDER);
-    expect(r.confidence).toBeGreaterThanOrEqual(0.92);
-  });
-
-  it("京东 domain alone → order", () => {
-    const r = classifyLayer1(email({ from: [{ address: "marketing@jd.com" }], subject: "限时优惠" }));
-    expect(r.category).toBe(CATEGORIES.ORDER);
-  });
-
-  it("拼多多 + 已签收 → order", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "no-reply@pinduoduo.com" }],
-      subject: "已签收，请确认",
-    }));
-    expect(r.category).toBe(CATEGORIES.ORDER);
-  });
-
-  it("Amazon → order", () => {
-    const r = classifyLayer1(email({ from: [{ address: "auto-confirm@amazon.com" }], subject: "Your order has shipped" }));
-    expect(r.category).toBe(CATEGORIES.ORDER);
-  });
-});
-
-describe("Layer 1 — travel", () => {
-  it("携程 → travel", () => {
-    const r = classifyLayer1(email({ from: [{ address: "noreply@ctrip.com" }], subject: "您的酒店预订" }));
-    expect(r.category).toBe(CATEGORIES.TRAVEL);
-  });
-
-  it("12306 → travel", () => {
-    const r = classifyLayer1(email({ from: [{ address: "no-reply@12306.cn" }], subject: "出票成功" }));
-    expect(r.category).toBe(CATEGORIES.TRAVEL);
-  });
-
-  it("航班 keyword without travel domain → travel medium-confidence", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "noreply@example.com" }],
-      subject: "您的航班 CA1234 出票成功",
-    }));
-    expect(r.category).toBe(CATEGORIES.TRAVEL);
-    expect(r.confidence).toBeGreaterThanOrEqual(0.85);
-  });
-});
-
-describe("Layer 1 — government", () => {
-  it(".gov.cn → government", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "notify@beijing.gov.cn" }],
-      subject: "您的纳税申报已提交",
-    }));
-    expect(r.category).toBe(CATEGORIES.GOVERNMENT);
-  });
-
-  it("社保 keyword alone → government", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "info@somewebsite.com" }],
-      subject: "您的社保缴费记录",
-    }));
-    expect(r.category).toBe(CATEGORIES.GOVERNMENT);
-  });
-});
-
-describe("Layer 1 — register", () => {
-  it("验证码 → register", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "noreply@somesite.com" }],
-      subject: "您的验证码是 1234",
-    }));
-    expect(r.category).toBe(CATEGORIES.REGISTER);
-  });
-
-  it("Password reset → register", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "support@app.io" }],
-      subject: "Password reset request",
-    }));
-    expect(r.category).toBe(CATEGORIES.REGISTER);
-  });
-
-  it("Welcome to → register lower confidence", () => {
-    const r = classifyLayer1(email({ subject: "Welcome to ChainlessChain" }));
-    expect(r.category).toBe(CATEGORIES.REGISTER);
-    expect(r.confidence).toBeLessThan(0.85); // → Layer 2 in orchestrator
-  });
-});
-
-describe("Layer 1 — notify (marketing)", () => {
-  it("List-Unsubscribe header → notify", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "newsletter@example.com" }],
-      subject: "Our weekly digest",
-      indicatorHeaders: { "list-unsubscribe": "<mailto:unsub@example.com>" },
-    }));
-    expect(r.category).toBe(CATEGORIES.NOTIFY);
-  });
-
-  it("Precedence: bulk → notify", () => {
-    const r = classifyLayer1(email({
-      headers: { precedence: "bulk" },
-    }));
-    expect(r.category).toBe(CATEGORIES.NOTIFY);
-  });
-
-  it("Auto-Submitted: auto-generated → notify", () => {
-    const r = classifyLayer1(email({
-      headers: { "auto-submitted": "auto-generated" },
-    }));
-    expect(r.category).toBe(CATEGORIES.NOTIFY);
-  });
-
-  it("Marketing header doesn't override bill_bank (specificity wins)", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "promo@cmbchina.com" }],
-      subject: "招行卡片新优惠",
-      indicatorHeaders: { "list-unsubscribe": "<...>" },
-    }));
-    expect(r.category).toBe(CATEGORIES.BILL_BANK);
-  });
-});
-
-describe("Layer 1 — defaults & malformed input", () => {
-  it("no signals → other with 0 confidence", () => {
-    const r = classifyLayer1(email({
-      from: [{ address: "friend@gmail.com" }],
-      subject: "Hi how are you",
-    }));
-    expect(r.category).toBe(CATEGORIES.OTHER);
-    expect(r.confidence).toBe(0);
-  });
-
-  it("null input → other", () => {
-    const r = classifyLayer1(null);
-    expect(r.category).toBe(CATEGORIES.OTHER);
-  });
-
-  it("layer field is 'L1'", () => {
-    const r = classifyLayer1(email({ from: [{ address: "x@taobao.com" }] }));
-    expect(r.layer).toBe("L1");
-  });
-});
-
-// ─── Layer 2 — LLM disambiguation ────────────────────────────────────────
-
-describe("Layer 2 LLM classifier", () => {
-  it("parses LLM JSON response into category/confidence/reason", async () => {
-    const llm = new MockLLMClient({
-      reply: '{"category":"order","confidence":0.88,"reason":"shipment notification"}',
-    });
-    const r = await classifyLayer2(email({ subject: "ambiguous" }), { llm });
-    expect(r.category).toBe(CATEGORIES.ORDER);
-    expect(r.confidence).toBe(0.88);
-    expect(r.reason).toContain("shipment");
-    expect(r.layer).toBe("L2");
-  });
-
-  it("strips markdown code fences", async () => {
-    const llm = new MockLLMClient({
-      reply: '```json\n{"category":"travel","confidence":0.9}\n```',
-    });
-    const r = await classifyLayer2(email(), { llm });
-    expect(r.category).toBe(CATEGORIES.TRAVEL);
-  });
-
-  it("regex-falls back to find first {...} when commentary precedes JSON", async () => {
-    const llm = new MockLLMClient({
-      reply: 'Sure, here is my classification: {"category":"register","confidence":0.6}',
-    });
-    const r = await classifyLayer2(email(), { llm });
-    expect(r.category).toBe(CATEGORIES.REGISTER);
-  });
-
-  it("malformed JSON → falls back to layer1 result", async () => {
-    const llm = new MockLLMClient({ reply: "I think it's an order email" });
-    const fallback = { category: CATEGORIES.NOTIFY, confidence: 0.4, ruleName: "fallback" };
-    const r = await classifyLayer2(email(), { llm, fallback });
-    expect(r.category).toBe(CATEGORIES.NOTIFY);
-    expect(r.layer).toBe("L1-fallback");
-  });
-
-  it("LLM throws → falls back to layer1 result", async () => {
-    const llm = new MockLLMClient({});
-    llm.chat = async () => { throw new Error("Ollama down"); };
-    const fallback = { category: CATEGORIES.BILL_BANK, confidence: 0.7 };
-    const r = await classifyLayer2(email(), { llm, fallback });
-    expect(r.category).toBe(CATEGORIES.BILL_BANK);
-    expect(r.layer).toBe("L1-fallback");
-  });
-
-  it("unknown category from LLM → falls back to fallback / OTHER", async () => {
-    const llm = new MockLLMClient({ reply: '{"category":"alien-spam","confidence":0.9}' });
-    const r = await classifyLayer2(email(), { llm });
-    expect(r.category).toBe(CATEGORIES.OTHER);
-    expect(r.layer).toBe("L1-fallback");
-  });
-
-  it("no LLM → throws", async () => {
-    await expect(classifyLayer2(email(), {})).rejects.toThrow(/llm/i);
-  });
-
-  it("parseLayer2Response: strict JSON", () => {
-    expect(parseLayer2Response('{"category":"order"}')).toEqual({ category: "order" });
-  });
-
-  it("parseLayer2Response: empty / non-json → null", () => {
-    expect(parseLayer2Response("")).toBeNull();
-    expect(parseLayer2Response("just text no json")).toBeNull();
-  });
-});
-
-// ─── classifyEmail orchestrator ─────────────────────────────────────────
-
-describe("classifyEmail orchestrator", () => {
-  it("high-confidence layer1 short-circuits layer2 even when LLM provided", async () => {
-    const llm = new MockLLMClient({ reply: '{"category":"other"}' });
-    const r = await classifyEmail(email({
-      from: [{ address: "x@taobao.com" }],
-      subject: "订单已发货",
-    }), { llm });
-    expect(r.layer).toBe("L1");
-    expect(r.category).toBe(CATEGORIES.ORDER);
-    expect(llm.calls).toHaveLength(0); // LLM NOT called
-  });
-
-  it("low-confidence layer1 → falls through to layer2", async () => {
-    const llm = new MockLLMClient({
-      reply: '{"category":"register","confidence":0.7}',
-    });
-    const r = await classifyEmail(email({
-      from: [{ address: "service@unknown-bank.example" }],
-      subject: "Welcome to our service",
-    }), { llm });
-    expect(r.layer).toBe("L2");
-    expect(r.category).toBe(CATEGORIES.REGISTER);
-    expect(llm.calls).toHaveLength(1);
-  });
-
-  it("no LLM + low-confidence layer1 → returns layer1 as-is", async () => {
-    const r = await classifyEmail(email());
-    expect(r.layer).toBe("L1");
-    expect(r.category).toBe(CATEGORIES.OTHER);
-  });
-
-  it("disableLayer2 forces layer1-only even with LLM provided", async () => {
-    const llm = new MockLLMClient({ reply: '{"category":"order"}' });
-    const r = await classifyEmail(email(), { llm, disableLayer2: true });
-    expect(r.layer).toBe("L1");
-    expect(llm.calls).toHaveLength(0);
-  });
-
-  it("minLayer1Confidence threshold respected (0.99 forces layer2)", async () => {
-    const llm = new MockLLMClient({ reply: '{"category":"travel","confidence":0.7}' });
-    const r = await classifyEmail(email({
-      from: [{ address: "x@taobao.com" }],
-      subject: "订单",
-    }), { llm, minLayer1Confidence: 0.99 });
-    // taobao + 订单 hits 0.95 < 0.99 → layer 2 fires
-    expect(r.layer).toBe("L2");
-  });
-
-  it("ALL_CATEGORIES contains the 8 documented categories", () => {
-    expect(ALL_CATEGORIES).toHaveLength(8);
-    expect(ALL_CATEGORIES).toEqual(
-      expect.arrayContaining([
-        "bill_bank", "bill_credit", "order", "travel",
-        "government", "register", "notify", "other",
-      ])
-    );
-  });
-});

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

@@ -1,334 +0,0 @@
-"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);
-  });
-});