@chainlesschain/personal-data-hub 0.4.6 → 0.4.18

package/__tests__/adapters/shopping-dianping.test.js

@@ -0,0 +1,239 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  DianpingAdapter,
+  orderToRecord,
+  extractOrders,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/shopping-dianping");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-dianping-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+const COOKIES = "dper=abc; _lxsdk=xyz; cy=1";
+
+describe("constants", () => {
+  it("exposes name/version/schema", () => {
+    expect(NAME).toBe("shopping-dianping");
+    expect(VERSION).toBe("0.1.0");
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+});
+
+describe("orderToRecord", () => {
+  it("maps a Dianping group-buy order (poi/deals/yuan amount)", () => {
+    const rec = orderToRecord({
+      orderId: "DP1",
+      shopName: "海底捞火锅(国贸店)",
+      dealList: [{ dealName: "双人套餐", quantity: 1, price: "238" }],
+      orderTime: 1716383021000,
+      payTime: 1716383040000,
+      statusText: "已消费",
+      totalPrice: "238.00",
+    });
+    expect(rec).toMatchObject({
+      vendorId: "dianping",
+      orderId: "DP1",
+      merchantName: "海底捞火锅(国贸店)",
+      status: "delivered",
+    });
+    expect(rec.totalAmount).toEqual({ value: 238, currency: "CNY" });
+    expect(rec.items[0]).toMatchObject({ name: "双人套餐", quantity: 1, unitPrice: 238 });
+    expect(rec.placedAt).toBe(1716383021000);
+  });
+
+  it("falls back to 分 (cents) field when no 元 field present", () => {
+    const rec = orderToRecord({ orderId: "DP2", shopName: "星巴克", totalFen: 4500 });
+    expect(rec.totalAmount.value).toBe(45);
+  });
+
+  it("maps refund / cancelled status", () => {
+    expect(orderToRecord({ orderId: "R", shopName: "x", statusText: "已退款" }).status).toBe("refunded");
+    expect(orderToRecord({ orderId: "C", shopName: "x", statusText: "已取消" }).status).toBe("cancelled");
+  });
+
+  it("drops id-less rows; default merchant 大众点评", () => {
+    expect(orderToRecord({ shopName: "x" })).toBe(null);
+    expect(orderToRecord({ orderId: "M" }).merchantName).toBe("大众点评");
+  });
+});
+
+describe("extractOrders", () => {
+  it("pulls list from common shapes", () => {
+    expect(extractOrders({ orders: [{ orderId: "A" }] })).toHaveLength(1);
+    expect(extractOrders({ data: { records: [{ orderId: "B" }] } })).toHaveLength(1);
+    expect(extractOrders({ orderList: [{ orderId: "C" }] })).toHaveLength(1);
+    expect(extractOrders({})).toEqual([]);
+    expect(extractOrders(null)).toEqual([]);
+  });
+});
+
+describe("DianpingAdapter snapshot mode", () => {
+  const SNAPSHOT = JSON.stringify({
+    schemaVersion: 1,
+    snapshottedAt: 1716383000000,
+    vendor: "dianping",
+    account: { userId: "u1", displayName: "我" },
+    events: [
+      {
+        kind: "order",
+        id: "order-DPS1",
+        orderId: "DPS1",
+        merchantName: "西贝莜面村",
+        platform: "groupbuy",
+        items: [{ name: "莜面套餐", quantity: 2, unitPrice: 88 }],
+        placedAt: 1716300000000,
+        status: "已完成",
+        totalAmount: { value: 176, currency: "CNY" },
+      },
+    ],
+  });
+
+  it("authenticate validates inputPath readability", async () => {
+    const p = writeTmp(SNAPSHOT);
+    try {
+      const a = new DianpingAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      const bad = await a.authenticate({ inputPath: path.join(os.tmpdir(), "nope-dp.json") });
+      expect(bad.ok).toBe(false);
+      expect(bad.reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync yields order + normalize end-to-end", async () => {
+    const p = writeTmp(SNAPSHOT);
+    try {
+      const a = new DianpingAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      expect(items[0].originalId).toBe("dianping:order:order-DPS1");
+      const batch = a.normalize(items[0]);
+      expect(batch.events[0].subtype).toBe("order");
+      expect(batch.events[0].content.amount).toMatchObject({ value: 176, direction: "out" });
+      expect(batch.persons.find((x) => x.subtype === "merchant").names).toEqual(["西贝莜面村"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("schemaVersion mismatch throws", async () => {
+    const p = writeTmp(JSON.stringify({ schemaVersion: 9, events: [] }));
+    try {
+      const a = new DianpingAdapter();
+      await expect(collect(a.sync({ inputPath: p }))).rejects.toThrow(/schemaVersion mismatch/);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+});
+
+describe("DianpingAdapter cookie-api mode", () => {
+  it("authenticate cookie mode requires userId", async () => {
+    const noId = new DianpingAdapter({ account: { cookies: COOKIES } });
+    expect((await noId.authenticate()).reason).toBe("NO_ACCOUNT_USER_ID");
+    const ok = new DianpingAdapter({ account: { cookies: COOKIES, userId: "u1" } });
+    expect(await ok.authenticate()).toEqual({ ok: true, account: "u1", mode: "cookie" });
+  });
+
+  it("sync fetches, paginates, maps + normalizes", async () => {
+    const pages = [
+      { orderList: [{ orderId: "CK1", shopName: "肯德基", payMoney: "39.9", orderTime: 1716383021000, statusText: "已消费" }] },
+      { orderList: [] },
+    ];
+    const calls = [];
+    const fetchFn = async ({ url, cookies, query, sign }) => {
+      calls.push({ url, cookies, page: query.page, sign });
+      return pages[query.page - 1] || { orderList: [] };
+    };
+    const a = new DianpingAdapter({ account: { cookies: COOKIES, userId: "u1" }, fetchFn });
+    const items = await collect(a.sync({ sinceWatermark: 0 }));
+    expect(items).toHaveLength(1);
+    expect(items[0].originalId).toBe("CK1");
+    expect(calls[0].cookies).toBe(COOKIES);
+    expect(calls[0].sign).toBe(null);
+    const batch = a.normalize(items[0]);
+    expect(batch.events[0].content.amount).toMatchObject({ value: 39.9, direction: "out" });
+  });
+
+  it("invokes signProvider when configured", async () => {
+    const signCalls = [];
+    const a = new DianpingAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async ({ query }) =>
+        query.page === 1 ? { orders: [{ orderId: "S1", shopName: "x" }] } : { orders: [] },
+      signProvider: async (ctx) => {
+        signCalls.push(ctx);
+        return "MTGSIG-TOKEN";
+      },
+    });
+    const items = await collect(a.sync({ sinceWatermark: 0 }));
+    expect(items).toHaveLength(1);
+    expect(signCalls).toHaveLength(1);
+    expect(signCalls[0].cookies).toBe(COOKIES);
+  });
+
+  it("stops at sinceWatermark", async () => {
+    const a = new DianpingAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async () => ({
+        orderList: [
+          { orderId: "NEW", shopName: "x", orderTime: 2_000_000_000_000 },
+          { orderId: "OLD", shopName: "x", orderTime: 1_000_000_000_000 },
+        ],
+      }),
+    });
+    const items = await collect(a.sync({ sinceWatermark: 1_500_000_000_000, pageSize: 2 }));
+    expect(items.map((x) => x.originalId)).toEqual(["NEW"]);
+  });
+
+  it("respects opts.limit", async () => {
+    const a = new DianpingAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async () => ({
+        orderList: [
+          { orderId: "L1", shopName: "x", orderTime: 2_000_000_000_000 },
+          { orderId: "L2", shopName: "x", orderTime: 2_000_000_000_001 },
+        ],
+      }),
+    });
+    const items = await collect(a.sync({ sinceWatermark: 0, limit: 1, pageSize: 2 }));
+    expect(items).toHaveLength(1);
+  });
+
+  it("empty/login-redirect response yields zero (no crash)", async () => {
+    const a = new DianpingAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async () => "<html>login</html>",
+    });
+    expect(await collect(a.sync({ sinceWatermark: 0 }))).toEqual([]);
+  });
+
+  it("default fetch throws when no fetchFn (wiring bug)", async () => {
+    const a = new DianpingAdapter({ account: { cookies: COOKIES, userId: "u1" } });
+    await expect(collect(a.sync({ sinceWatermark: 0 }))).rejects.toThrow(/no fetchFn configured/);
+  });
+
+  it("no input throws", async () => {
+    const a = new DianpingAdapter();
+    await expect(collect(a.sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/social-csdn.test.js

@@ -0,0 +1,175 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  CsdnAdapter,
+  extractList,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-csdn");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-csdn-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+const COOKIES = "UserName=alice; UserToken=xyz";
+
+const SNAP = JSON.stringify({
+  schemaVersion: 1,
+  snapshottedAt: 1716383000000,
+  account: { username: "alice", name: "Alice" },
+  events: [
+    { kind: "article", id: "article-101", articleId: "101", title: "<p>Vue 源码解析</p>", viewCount: 999, collectCount: 50, createdTime: 1716300000, url: "https://blog.csdn.net/alice/article/details/101" },
+    { kind: "favourite", id: "fav-202", itemId: "202", title: "Rust 入门", url: "https://x/202", source: "blog", capturedAt: 1716310000000 },
+    { kind: "follow", id: "follow-bob", username: "bob", name: "Bob", capturedAt: 1716320000000 },
+  ],
+});
+
+describe("constants + extractList", () => {
+  it("name/version/schema", () => {
+    expect(NAME).toBe("social-csdn");
+    expect(VERSION).toBe("0.1.0");
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+  it("extractList tolerant", () => {
+    expect(extractList({ list: [{ id: 1 }] })).toHaveLength(1);
+    expect(extractList({ data: { list: [{ id: 1 }] } })).toHaveLength(1);
+    expect(extractList({ data: { records: [{ id: 1 }] } })).toHaveLength(1);
+    expect(extractList({})).toEqual([]);
+  });
+});
+
+describe("CsdnAdapter snapshot mode", () => {
+  it("authenticate validates inputPath", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new CsdnAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      expect((await a.authenticate({ inputPath: path.join(os.tmpdir(), "no-csdn.json") })).reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync 3 kinds + normalize article→post(html-stripped)/favourite→like/follow→person", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new CsdnAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items.map((x) => x.kind)).toEqual(["article", "favourite", "follow"]);
+
+      const art = a.normalize(items[0]);
+      expect(art.events[0].subtype).toBe("post");
+      expect(art.events[0].content.text).toBe("Vue 源码解析"); // html stripped
+      expect(art.events[0].extra.viewCount).toBe(999);
+      expect(art.events[0].extra.collectCount).toBe(50);
+
+      const fav = a.normalize(items[1]);
+      expect(fav.events[0].subtype).toBe("like");
+      expect(fav.events[0].content.title).toBe("Rust 入门");
+
+      const fol = a.normalize(items[2]);
+      expect(fol.persons[0].subtype).toBe("contact");
+      expect(fol.persons[0].names).toEqual(["Bob"]);
+      expect(fol.persons[0].identifiers["csdn-username"]).toEqual(["bob"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("include filter + limit + schema mismatch + unknown kind", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new CsdnAdapter();
+      expect((await collect(a.sync({ inputPath: p, include: { article: false, follow: false } }))).map((x) => x.kind)).toEqual(["favourite"]);
+      expect(await collect(a.sync({ inputPath: p, limit: 2 }))).toHaveLength(2);
+      expect(() => a.normalize({ kind: "bogus", payload: {} })).toThrow(/unknown kind/);
+    } finally {
+      fs.unlinkSync(p);
+    }
+    const bad = writeTmp(JSON.stringify({ schemaVersion: 9, events: [] }));
+    try {
+      const a = new CsdnAdapter();
+      await expect(collect(a.sync({ inputPath: bad }))).rejects.toThrow(/schemaVersion mismatch/);
+    } finally {
+      fs.unlinkSync(bad);
+    }
+  });
+});
+
+describe("CsdnAdapter cookie-api mode", () => {
+  it("authenticate requires username", async () => {
+    const noU = new CsdnAdapter({ account: { cookies: COOKIES } });
+    expect((await noU.authenticate()).reason).toBe("NO_ACCOUNT_USERNAME");
+    const ok = new CsdnAdapter({ account: { cookies: COOKIES, username: "alice" } });
+    expect(await ok.authenticate()).toEqual({ ok: true, account: "alice", mode: "cookie" });
+  });
+
+  it("sync fetches articles/favourites/followees, normalizes", async () => {
+    const byUrl = (u) => (u.includes("get-business-list") ? "articles" : u.includes("favorite") ? "favourites" : "followees");
+    const data = {
+      articles: [{ articleId: "A1", title: "Go 并发", viewCount: 10, createdTime: 1716300000 }],
+      favourites: [{ id: "F1", title: "K8s 实践", source: "blog", created_at: 1716310000 }],
+      followees: [{ username: "carol", name: "Carol" }],
+    };
+    const calls = [];
+    const a = new CsdnAdapter({
+      account: { cookies: COOKIES, username: "alice" },
+      fetchFn: async ({ url, cookies, query, sign }) => {
+        const k = byUrl(url);
+        calls.push({ k, cookies, page: query.page, sign });
+        return { data: { list: query.page === 1 ? data[k] : [] } };
+      },
+    });
+    const items = await collect(a.sync({}));
+    expect(items.map((x) => x.kind).sort()).toEqual(["article", "favourite", "follow"]);
+    expect(calls.every((c) => c.cookies === COOKIES && c.sign === null)).toBe(true);
+    const art = a.normalize(items.find((x) => x.kind === "article"));
+    expect(art.events[0].content.title).toBe("Go 并发");
+    const fol = a.normalize(items.find((x) => x.kind === "follow"));
+    expect(fol.persons[0].names).toEqual(["Carol"]);
+  });
+
+  it("invokes signProvider", async () => {
+    const signCalls = [];
+    const a = new CsdnAdapter({
+      account: { cookies: COOKIES, username: "alice" },
+      fetchFn: async ({ query }) => ({ list: query.page === 1 ? [{ articleId: "A1", title: "x" }] : [] }),
+      signProvider: async (ctx) => { signCalls.push(ctx); return "sig"; },
+    });
+    const items = await collect(a.sync({ include: { favourite: false, follow: false } }));
+    expect(items.length).toBeGreaterThan(0);
+    expect(signCalls.length).toBeGreaterThan(0);
+    expect(signCalls[0].cookies).toBe(COOKIES);
+  });
+
+  it("limit + empty/login + default fetch + no input", async () => {
+    const a1 = new CsdnAdapter({
+      account: { cookies: COOKIES, username: "alice" },
+      fetchFn: async ({ query }) => ({ list: query.page === 1 ? [{ articleId: "A1", title: "a" }, { articleId: "A2", title: "b" }] : [] }),
+    });
+    expect(await collect(a1.sync({ limit: 1 }))).toHaveLength(1);
+
+    const a2 = new CsdnAdapter({ account: { cookies: COOKIES, username: "alice" }, fetchFn: async () => "<html>login</html>" });
+    expect(await collect(a2.sync({}))).toEqual([]);
+
+    const a3 = new CsdnAdapter({ account: { cookies: COOKIES, username: "alice" } });
+    await expect(collect(a3.sync({}))).rejects.toThrow(/no fetchFn configured/);
+
+    const a4 = new CsdnAdapter();
+    await expect(collect(a4.sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/social-zhihu.test.js

@@ -0,0 +1,246 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  ZhihuAdapter,
+  extractData,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-zhihu");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-zhihu-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+const COOKIES = "z_c0=abc; d_c0=xyz";
+
+const SNAPSHOT = JSON.stringify({
+  schemaVersion: 1,
+  snapshottedAt: 1716383000000,
+  account: { urlToken: "alice", name: "Alice" },
+  events: [
+    {
+      kind: "answer",
+      id: "answer-101",
+      answerId: "101",
+      questionTitle: "如何评价 X?",
+      excerpt: "<p>我认为 X 很好</p>",
+      voteupCount: 42,
+      commentCount: 3,
+      createdTime: 1716300000,
+      url: "https://www.zhihu.com/answer/101",
+    },
+    {
+      kind: "favourite",
+      id: "fav-202",
+      itemId: "202",
+      title: "好文收藏",
+      collectionName: "技术",
+      capturedAt: 1716310000000,
+    },
+    {
+      kind: "follow",
+      id: "follow-bob",
+      memberToken: "bob",
+      name: "Bob",
+      headline: "工程师",
+      avatarUrl: "https://pic/bob.jpg",
+      capturedAt: 1716320000000,
+    },
+  ],
+});
+
+describe("constants", () => {
+  it("exposes name/version/schema", () => {
+    expect(NAME).toBe("social-zhihu");
+    expect(VERSION).toBe("0.1.0");
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+});
+
+describe("extractData", () => {
+  it("pulls data/items arrays; tolerant of bad shapes", () => {
+    expect(extractData({ data: [{ id: 1 }] })).toHaveLength(1);
+    expect(extractData({ items: [{ id: 1 }] })).toHaveLength(1);
+    expect(extractData({})).toEqual([]);
+    expect(extractData(null)).toEqual([]);
+  });
+});
+
+describe("ZhihuAdapter snapshot mode", () => {
+  it("authenticate validates inputPath readability", async () => {
+    const p = writeTmp(SNAPSHOT);
+    try {
+      const a = new ZhihuAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      const bad = await a.authenticate({ inputPath: path.join(os.tmpdir(), "nope-z.json") });
+      expect(bad.ok).toBe(false);
+      expect(bad.reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync yields all 3 kinds + normalize answer→post, favourite→like, follow→person", async () => {
+    const p = writeTmp(SNAPSHOT);
+    try {
+      const a = new ZhihuAdapter();
+      const real = await collect(a.sync({ inputPath: p }));
+      expect(real).toHaveLength(3);
+      expect(real.map((x) => x.kind)).toEqual(["answer", "favourite", "follow"]);
+
+      const ans = a.normalize(real[0]);
+      expect(ans.events[0].subtype).toBe("post");
+      expect(ans.events[0].content.text).toBe("我认为 X 很好"); // html stripped
+      expect(ans.events[0].extra.voteupCount).toBe(42);
+      expect(ans.events[0].extra.questionTitle).toBe("如何评价 X?");
+
+      const fav = a.normalize(real[1]);
+      expect(fav.events[0].subtype).toBe("like");
+      expect(fav.events[0].content.title).toBe("好文收藏");
+
+      const fol = a.normalize(real[2]);
+      expect(fol.persons[0].subtype).toBe("contact");
+      expect(fol.persons[0].names).toEqual(["Bob"]);
+      expect(fol.persons[0].identifiers["zhihu-token"]).toEqual(["bob"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("respects include filter + limit", async () => {
+    const p = writeTmp(SNAPSHOT);
+    try {
+      const a = new ZhihuAdapter();
+      const onlyFollow = await collect(a.sync({ inputPath: p, include: { answer: false, favourite: false } }));
+      expect(onlyFollow.map((x) => x.kind)).toEqual(["follow"]);
+      const limited = await collect(a.sync({ inputPath: p, limit: 1 }));
+      expect(limited).toHaveLength(1);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("schemaVersion mismatch throws", async () => {
+    const p = writeTmp(JSON.stringify({ schemaVersion: 9, events: [] }));
+    try {
+      const a = new ZhihuAdapter();
+      await expect(collect(a.sync({ inputPath: p }))).rejects.toThrow(/schemaVersion mismatch/);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("normalize throws on unknown kind", () => {
+    const a = new ZhihuAdapter();
+    expect(() => a.normalize({ kind: "bogus", payload: {} })).toThrow(/unknown kind/);
+  });
+});
+
+describe("ZhihuAdapter cookie-api mode", () => {
+  it("authenticate cookie mode requires urlToken", async () => {
+    const noTok = new ZhihuAdapter({ account: { cookies: COOKIES } });
+    expect((await noTok.authenticate()).reason).toBe("NO_ACCOUNT_URL_TOKEN");
+    const ok = new ZhihuAdapter({ account: { cookies: COOKIES, urlToken: "alice" } });
+    expect(await ok.authenticate()).toEqual({ ok: true, account: "alice", mode: "cookie" });
+  });
+
+  it("sync fetches answers/followees/collections, paginates, normalizes", async () => {
+    const byUrl = (url) => {
+      if (url.includes("/answers")) return "answers";
+      if (url.includes("/followees")) return "followees";
+      if (url.includes("/collections")) return "collections";
+      return "?";
+    };
+    const data = {
+      answers: [
+        { id: "A1", question: { title: "Q1" }, excerpt: "ans1", voteup_count: 9, created_time: 1716300000 },
+      ],
+      followees: [{ url_token: "bob", name: "Bob", headline: "eng" }],
+      collections: [{ id: "C1", title: "我的收藏", is_public: true }],
+    };
+    const calls = [];
+    const fetchFn = async ({ url, cookies, query, sign }) => {
+      const k = byUrl(url);
+      calls.push({ k, cookies, offset: query.offset, sign });
+      // single page each
+      return { data: query.offset === 0 ? data[k] : [], paging: { is_end: query.offset !== 0 } };
+    };
+    const a = new ZhihuAdapter({ account: { cookies: COOKIES, urlToken: "alice" }, fetchFn });
+    const items = await collect(a.sync({}));
+    expect(items.map((x) => x.kind).sort()).toEqual(["answer", "favourite", "follow"]);
+    expect(calls.every((c) => c.cookies === COOKIES)).toBe(true);
+    expect(calls.every((c) => c.sign === null)).toBe(true);
+
+    const ans = a.normalize(items.find((x) => x.kind === "answer"));
+    expect(ans.events[0].content.title).toBe("Q1");
+    expect(ans.events[0].extra.voteupCount).toBe(9);
+    const fol = a.normalize(items.find((x) => x.kind === "follow"));
+    expect(fol.persons[0].names).toEqual(["Bob"]);
+    expect(fol.persons[0].identifiers["zhihu-token"]).toEqual(["bob"]);
+    const fav = a.normalize(items.find((x) => x.kind === "favourite"));
+    expect(fav.events[0].content.title).toBe("我的收藏");
+  });
+
+  it("invokes signProvider when configured", async () => {
+    const signCalls = [];
+    const a = new ZhihuAdapter({
+      account: { cookies: COOKIES, urlToken: "alice" },
+      fetchFn: async ({ query }) =>
+        query.offset === 0 ? { data: [{ id: "A1", question: { title: "Q" }, excerpt: "x" }], paging: { is_end: true } } : { data: [], paging: { is_end: true } },
+      signProvider: async (ctx) => {
+        signCalls.push(ctx);
+        return "x-zse-96-value";
+      },
+      // only answers to keep it short
+    });
+    const items = await collect(a.sync({ include: { follow: false, favourite: false } }));
+    expect(items.length).toBeGreaterThan(0);
+    expect(signCalls.length).toBeGreaterThan(0);
+    expect(signCalls[0].cookies).toBe(COOKIES);
+  });
+
+  it("respects opts.limit across kinds", async () => {
+    const a = new ZhihuAdapter({
+      account: { cookies: COOKIES, urlToken: "alice" },
+      fetchFn: async ({ query }) =>
+        query.offset === 0
+          ? { data: [{ id: "A1", question: { title: "Q" }, excerpt: "x" }, { id: "A2", question: { title: "Q2" }, excerpt: "y" }], paging: { is_end: true } }
+          : { data: [], paging: { is_end: true } },
+    });
+    const items = await collect(a.sync({ limit: 1 }));
+    expect(items).toHaveLength(1);
+  });
+
+  it("is_end stops pagination; empty data yields zero (no crash)", async () => {
+    const a = new ZhihuAdapter({
+      account: { cookies: COOKIES, urlToken: "alice" },
+      fetchFn: async () => "not-json-login-redirect",
+    });
+    expect(await collect(a.sync({}))).toEqual([]);
+  });
+
+  it("default fetch throws when no fetchFn", async () => {
+    const a = new ZhihuAdapter({ account: { cookies: COOKIES, urlToken: "alice" } });
+    await expect(collect(a.sync({}))).rejects.toThrow(/no fetchFn configured/);
+  });
+
+  it("sync with no input/cookie throws", async () => {
+    const a = new ZhihuAdapter();
+    await expect(collect(a.sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});