@chainlesschain/personal-data-hub 0.4.7 → 0.4.23

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

@@ -0,0 +1,165 @@
+"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 {
+  DongchediAdapter,
+  extractData,
+  isEnd,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-dongchedi");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-dcd-${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 = "tt_webid=abc; sessionid=xyz";
+
+const SNAP = JSON.stringify({
+  schemaVersion: 1,
+  snapshottedAt: 1716383000000,
+  account: { userId: "u1" },
+  events: [
+    { kind: "favourite", id: "fav-1", itemId: "G1", title: "2026 新能源车横评", contentType: "article", url: "https://x/G1", capturedAt: 1716300000000 },
+    { kind: "follow", id: "follow-S1", followId: "S1", name: "理想 L 系列", followType: "series", capturedAt: 1716320000000 },
+  ],
+});
+
+describe("constants + helpers", () => {
+  it("name/version/schema", () => {
+    expect(NAME).toBe("social-dongchedi");
+    expect(VERSION).toBe("0.1.0");
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+  it("extractData tolerant", () => {
+    expect(extractData({ data: [{ id: 1 }] })).toHaveLength(1);
+    expect(extractData({ data: { favorite_list: [{ id: 1 }] } })).toHaveLength(1);
+    expect(extractData({ data: { follow_list: [{ id: 1 }] } })).toHaveLength(1);
+    expect(extractData({})).toEqual([]);
+  });
+  it("isEnd reads has_more", () => {
+    expect(isEnd({ data: { has_more: false } })).toBe(true);
+    expect(isEnd({ has_more: 0 })).toBe(true);
+    expect(isEnd({ data: { has_more: true } })).toBe(false);
+  });
+});
+
+describe("DongchediAdapter snapshot mode", () => {
+  it("authenticate validates inputPath", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new DongchediAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      expect((await a.authenticate({ inputPath: path.join(os.tmpdir(), "no-dcd.json") })).reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync 2 kinds + normalize favourite→like / follow→person", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new DongchediAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items.map((x) => x.kind)).toEqual(["favourite", "follow"]);
+
+      const fav = a.normalize(items[0]);
+      expect(fav.events[0].subtype).toBe("like");
+      expect(fav.events[0].content.title).toBe("收藏: 2026 新能源车横评");
+      expect(fav.events[0].extra.contentType).toBe("article");
+
+      const fol = a.normalize(items[1]);
+      expect(fol.persons[0].subtype).toBe("contact");
+      expect(fol.persons[0].names).toEqual(["理想 L 系列"]);
+      expect(fol.persons[0].identifiers["dongchedi-id"]).toEqual(["S1"]);
+      expect(fol.persons[0].extra.followType).toBe("series");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("include + limit + schema mismatch + unknown kind", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new DongchediAdapter();
+      expect((await collect(a.sync({ inputPath: p, include: { favourite: false } }))).map((x) => x.kind)).toEqual(["follow"]);
+      expect(await collect(a.sync({ inputPath: p, limit: 1 }))).toHaveLength(1);
+      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 DongchediAdapter();
+      await expect(collect(a.sync({ inputPath: bad }))).rejects.toThrow(/schemaVersion mismatch/);
+    } finally {
+      fs.unlinkSync(bad);
+    }
+  });
+});
+
+describe("DongchediAdapter cookie-api mode", () => {
+  it("authenticate cookie (userId optional)", async () => {
+    const a = new DongchediAdapter({ account: { cookies: COOKIES } });
+    expect(await a.authenticate()).toEqual({ ok: true, account: null, mode: "cookie" });
+  });
+
+  it("sync fetches favourites + follows, normalizes", async () => {
+    const byUrl = (u) => (u.includes("favorite") ? "favourite" : "follow");
+    const data = {
+      favourite: [{ group_id: "G1", title: "试驾视频", content_type: "video", create_time: 1716300000 }],
+      follow: [{ series_id: "S9", series_name: "比亚迪汉", follow_time: 1716320000 }],
+    };
+    const calls = [];
+    const a = new DongchediAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async ({ url, cookies, query, sign }) => {
+        const k = byUrl(url);
+        calls.push({ k, cookies, offset: query.offset, sign });
+        return { data: { list: query.offset === 0 ? data[k] : [], has_more: false } };
+      },
+    });
+    const items = await collect(a.sync({}));
+    expect(items.map((x) => x.kind).sort()).toEqual(["favourite", "follow"]);
+    expect(calls.every((c) => c.cookies === COOKIES && c.sign === null)).toBe(true);
+    const fav = a.normalize(items.find((x) => x.kind === "favourite"));
+    expect(fav.events[0].content.title).toBe("收藏: 试驾视频");
+    const fol = a.normalize(items.find((x) => x.kind === "follow"));
+    expect(fol.persons[0].names).toEqual(["比亚迪汉"]);
+    expect(fol.persons[0].extra.followType).toBe("series");
+  });
+
+  it("invokes signProvider + limit + empty + default fetch + no input", async () => {
+    const signCalls = [];
+    const a = new DongchediAdapter({
+      account: { cookies: COOKIES },
+      fetchFn: async ({ query }) => ({ data: { list: query.offset === 0 ? [{ group_id: "G1", title: "x" }, { group_id: "G2", title: "y" }] : [], has_more: false } }),
+      signProvider: async (ctx) => { signCalls.push(ctx); return "x-bogus"; },
+    });
+    expect(await collect(a.sync({ limit: 1, include: { follow: false } }))).toHaveLength(1);
+    expect(signCalls.length).toBeGreaterThan(0);
+    expect(signCalls[0].cookies).toBe(COOKIES);
+
+    const a2 = new DongchediAdapter({ account: { cookies: COOKIES }, fetchFn: async () => "<html>login</html>" });
+    expect(await collect(a2.sync({}))).toEqual([]);
+
+    const a3 = new DongchediAdapter({ account: { cookies: COOKIES } });
+    await expect(collect(a3.sync({}))).rejects.toThrow(/no fetchFn configured/);
+
+    const a4 = new DongchediAdapter();
+    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/);
+  });
+});

package/__tests__/adapters/travel-ctrip.test.js

@@ -9,6 +9,8 @@ const crypto = require("node:crypto");
 const {
   CtripAdapter,
   parseRecords,
+  orderToRecord,
+  extractOrders,
   TYPE_MAP,
   NAME,
   VERSION,
@@ -43,7 +45,7 @@ const FLIGHT_ORDER = {
 describe("constants + TYPE_MAP", () => {
   it("exposes name/version", () => {
     expect(NAME).toBe("travel-ctrip");
-    expect(VERSION).toBe("0.6.0");
+    expect(VERSION).toBe("0.7.0");
   });
 
   it("maps ctrip order types to vehicleType", () => {
@@ -201,3 +203,175 @@ describe("CtripAdapter", () => {
     );
   });
 });
+
+describe("orderToRecord web-API aliases (cookie-api mode)", () => {
+  it("maps web order field names (bizType / amount / orderDate / departCity)", () => {
+    const rec = orderToRecord(
+      {
+        orderId: "W1",
+        bizType: "Flight",
+        departCity: "广州",
+        arriveCity: "成都",
+        amount: "899.5",
+        departureDate: 1716383021000,
+        contactName: "王五",
+        orderDate: "2026-04-01",
+      },
+      { capturedVia: "cookie-api" },
+    );
+    expect(rec).toMatchObject({
+      vendorId: "ctrip",
+      recordId: "W1",
+      vehicleType: "flight",
+      from: { city: "广州" },
+      to: { city: "成都" },
+      departureMs: 1716383021000,
+      traveler: "王五",
+    });
+    expect(rec.totalCost).toEqual({ value: 899.5, currency: "CNY" });
+    expect(rec.extras.capturedVia).toBe("cookie-api");
+  });
+
+  it("file-import rows keep priority + no capturedVia by default", () => {
+    const rec = orderToRecord({ orderId: "F1", type: "hotel", price: "300" });
+    expect(rec.vehicleType).toBe("hotel");
+    expect(rec.totalCost).toEqual({ value: 300, currency: "CNY" });
+    expect(rec.extras.capturedVia).toBeUndefined();
+  });
+});
+
+describe("extractOrders", () => {
+  it("pulls the list from common Ctrip response shapes", () => {
+    expect(extractOrders({ orders: [{ orderId: "A" }] })).toHaveLength(1);
+    expect(extractOrders({ data: { orderList: [{ orderId: "B" }] } })).toHaveLength(1);
+    expect(extractOrders({ result: { list: [{ orderId: "C" }] } })).toHaveLength(1);
+    expect(extractOrders({})).toEqual([]);
+    expect(extractOrders(null)).toEqual([]);
+  });
+});
+
+describe("CtripAdapter cookie-api mode", () => {
+  const COOKIES = "_bfa=abc; cticket=xyz; UUID=u1";
+
+  it("authenticate returns cookie mode (account OPTIONAL)", async () => {
+    const a = new CtripAdapter({ account: { cookies: COOKIES } });
+    expect(await a.authenticate()).toEqual({
+      ok: true,
+      account: null,
+      mode: "cookie",
+    });
+  });
+
+  it("authenticate fails on empty cookies", async () => {
+    const a = new CtripAdapter({ account: { cookies: "" } });
+    // empty cookies → no cookieAuth → falls through to ready (not cookie mode)
+    expect((await a.authenticate()).mode).toBe("ready");
+  });
+
+  it("sync fetches, paginates, maps + normalizes end-to-end", async () => {
+    const pages = [
+      {
+        orderList: [
+          {
+            orderId: "CK1",
+            bizType: "flight",
+            departCity: "上海",
+            arriveCity: "北京",
+            amount: "1200",
+            orderDate: 1716383021000,
+            flightNumber: "MU500",
+          },
+        ],
+      },
+      { orderList: [] }, // page 2 empty → stop
+    ];
+    const calls = [];
+    const fetchFn = async ({ url, cookies, query, sign }) => {
+      calls.push({ url, cookies, pageIndex: query.pageIndex, sign });
+      return pages[query.pageIndex - 1] || { orderList: [] };
+    };
+    const a = new CtripAdapter({
+      account: { cookies: COOKIES },
+      fetchFn,
+      // no signProvider → sign should be null (best-effort unsigned)
+    });
+    const items = await collect(a.sync({ sinceWatermark: 0 }));
+    expect(items).toHaveLength(1);
+    expect(items[0]).toMatchObject({ adapter: NAME, originalId: "CK1" });
+    expect(calls[0].cookies).toBe(COOKIES);
+    expect(calls[0].sign).toBe(null);
+    const batch = a.normalize(items[0]);
+    expect(batch.events[0].content.title).toBe("flight: 上海 → 北京");
+    expect(batch.events[0].content.amount).toMatchObject({ value: 1200 });
+  });
+
+  it("invokes signProvider when configured", async () => {
+    const fetchFn = async ({ query }) =>
+      query.pageIndex === 1 ? { orders: [{ orderId: "S1", type: "hotel" }] } : { orders: [] };
+    const signCalls = [];
+    const signProvider = async (ctx) => {
+      signCalls.push(ctx);
+      return "SIGNED-TOKEN";
+    };
+    const a = new CtripAdapter({ account: { cookies: COOKIES }, fetchFn, signProvider });
+    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 (older orders dropped)", async () => {
+    const fetchFn = async () => ({
+      orderList: [
+        { orderId: "NEW", type: "flight", orderDate: 2_000_000_000_000 },
+        { orderId: "OLD", type: "flight", orderDate: 1_000_000_000_000 },
+      ],
+    });
+    const a = new CtripAdapter({ account: { cookies: COOKIES }, fetchFn });
+    const items = await collect(a.sync({ sinceWatermark: 1_500_000_000_000, maxPages: 1 }));
+    expect(items.map((x) => x.originalId)).toEqual(["NEW"]);
+  });
+
+  it("respects opts.limit", async () => {
+    const fetchFn = async () => ({
+      orderList: [
+        { orderId: "L1", type: "flight", orderDate: 2_000_000_000_000 },
+        { orderId: "L2", type: "flight", orderDate: 2_000_000_000_001 },
+      ],
+    });
+    const a = new CtripAdapter({ account: { cookies: COOKIES }, fetchFn });
+    const items = await collect(a.sync({ sinceWatermark: 0, limit: 1, maxPages: 1 }));
+    expect(items).toHaveLength(1);
+  });
+
+  it("empty/login-redirect response yields zero (no crash)", async () => {
+    const a = new CtripAdapter({
+      account: { cookies: COOKIES },
+      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 CtripAdapter({ account: { cookies: COOKIES } });
+    await expect(collect(a.sync({ sinceWatermark: 0 }))).rejects.toThrow(
+      /no fetchFn configured/,
+    );
+  });
+
+  it("snapshot/file path takes priority over cookie mode", async () => {
+    const p = writeTmp(JSON.stringify([FLIGHT_ORDER]));
+    try {
+      const a = new CtripAdapter({
+        account: { cookies: COOKIES },
+        fetchFn: async () => {
+          throw new Error("fetchFn should NOT be called in file mode");
+        },
+      });
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items.map((x) => x.originalId)).toEqual(["CT1"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+});