@chainlesschain/personal-data-hub 0.4.6 → 0.4.18

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

@@ -9,6 +9,11 @@ const crypto = require("node:crypto");
 const {
   Train12306Adapter,
   parseRecords,
+  ticketsFromOrder,
+  extractCompletedOrders,
+  extractPendingOrders,
+  parse12306DateTime,
+  parseYyyymmdd,
   NAME,
   VERSION,
   SNAPSHOT_SCHEMA_VERSION,
@@ -62,7 +67,7 @@ function makeSnapshot(events, extra = {}) {
 describe("constants", () => {
   it("exposes name/version/schema", () => {
     expect(NAME).toBe("travel-12306");
-    expect(VERSION).toBe("0.6.0");
+    expect(VERSION).toBe("0.7.0");
     expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
     expect([...VALID_SNAPSHOT_KINDS]).toEqual(["ticket"]);
   });
@@ -277,3 +282,231 @@ describe("sync + parseRecords — file-import mode", () => {
     await expect(collect(a.sync({}))).rejects.toThrow(/needs opts\.inputPath/);
   });
 });
+
+// ─── §2.5 v0.3 cookie-api live fetch ────────────────────────────────────────
+
+// One raw 12306 order object (queryMyOrder shape) carrying a single ticket.
+function rawOrder(seq, overrides = {}) {
+  return {
+    sequence_no: seq,
+    order_date: "20240315",
+    ticket_total_price: "553.5",
+    tickets: [
+      {
+        ticket_no: "E123456789",
+        passenger_name: "张三",
+        passenger_id_no: "310101199001011234", // last6 = 011234
+        train_code: "G35",
+        from_station_name: "上海虹桥",
+        to_station_name: "北京南",
+        start_train_date_page: "2024-03-20 09:00",
+        arrive_train_date_page: "2024-03-20 14:00",
+        seat_type_name: "二等座",
+        coach_no: "05",
+        seat_no: "12A",
+        ticket_price: "553.5",
+        ...overrides,
+      },
+    ],
+  };
+}
+
+const COOKIE = "tk=abc; JSESSIONID=xyz; RAIL_DEVICEID=dev";
+
+describe("cookie-api helpers", () => {
+  it("extractCompletedOrders tolerates shape variants + junk", () => {
+    expect(extractCompletedOrders({ data: { OrderDTODataList: [1, 2] } })).toEqual([1, 2]);
+    expect(extractCompletedOrders({ data: { orderDTODataList: [3] } })).toEqual([3]);
+    expect(extractCompletedOrders(null)).toEqual([]);
+    expect(extractCompletedOrders({ data: {} })).toEqual([]);
+    expect(extractCompletedOrders("nope")).toEqual([]);
+  });
+
+  it("extractPendingOrders tolerates shape variants + junk", () => {
+    expect(extractPendingOrders({ data: { orderDBList: [1] } })).toEqual([1]);
+    expect(extractPendingOrders({ data: { orderDbList: [2] } })).toEqual([2]);
+    expect(extractPendingOrders({})).toEqual([]);
+  });
+
+  it("ticketsFromOrder flattens tickets with snake/camel fallbacks", () => {
+    const evs = ticketsFromOrder(rawOrder("SEQ1"), true);
+    expect(evs).toHaveLength(1);
+    expect(evs[0]).toMatchObject({
+      kind: "ticket",
+      id: "ticket-SEQ1:0",
+      orderSequenceNo: "SEQ1",
+      ticketNumber: "E123456789",
+      passengerName: "张三",
+      passengerIdLast6: "011234",
+      trainNumber: "G35",
+      fromStation: "上海虹桥",
+      toStation: "北京南",
+      seatTypeName: "二等座",
+      coachNo: "05",
+      seatNo: "12A",
+      ticketPrice: 553.5,
+      isCompleted: true,
+      capturedVia: "cookie-api",
+    });
+    // camelCase + *_page fallbacks
+    const camel = ticketsFromOrder(
+      {
+        sequenceNo: "SEQ2",
+        tickets: [
+          {
+            stationTrainCode: "D7",
+            passengerName: "李四",
+            from_station_name_page: "杭州东",
+            to_station_name_page: "南京南",
+            ticketPrice: "100",
+          },
+        ],
+      },
+      false,
+    );
+    expect(camel[0]).toMatchObject({
+      trainNumber: "D7",
+      fromStation: "杭州东",
+      toStation: "南京南",
+      ticketPrice: 100,
+      isCompleted: false,
+    });
+  });
+
+  it("ticketsFromOrder drops incomplete tickets + bad orders", () => {
+    expect(ticketsFromOrder(null, true)).toEqual([]);
+    expect(ticketsFromOrder({ tickets: [] }, true)).toEqual([]); // no sequence_no
+    // ticket missing passenger / train / stations → dropped
+    const evs = ticketsFromOrder(
+      { sequence_no: "S", tickets: [{ passenger_name: "x" }] },
+      true,
+    );
+    expect(evs).toEqual([]);
+  });
+
+  it("parse12306DateTime handles date / date-time / Chinese / blank", () => {
+    // 2024-03-20 09:00 Shanghai = 2024-03-20 01:00 UTC
+    expect(parse12306DateTime("2024-03-20 09:00")).toBe(Date.UTC(2024, 2, 20, 1, 0));
+    expect(parse12306DateTime("2024-03-20")).toBe(Date.UTC(2024, 2, 19, 16, 0));
+    expect(parse12306DateTime("")).toBeNull();
+    expect(parse12306DateTime(null)).toBeNull();
+    expect(parse12306DateTime("garbage")).toBeNull();
+  });
+
+  it("parseYyyymmdd parses compact dates", () => {
+    expect(parseYyyymmdd("20240315")).toBe(Date.UTC(2024, 2, 14, 16, 0));
+    expect(parseYyyymmdd("2024-03-15")).toBeNull();
+    expect(parseYyyymmdd(null)).toBeNull();
+  });
+});
+
+describe("authenticate — cookie-api mode", () => {
+  it("ok when account.cookies present (username optional)", async () => {
+    const a = new Train12306Adapter({ account: { cookies: COOKIE } });
+    expect(await a.authenticate({})).toEqual({
+      ok: true,
+      account: null,
+      mode: "cookie",
+    });
+  });
+
+  it("carries username when supplied alongside cookies", async () => {
+    const a = new Train12306Adapter({
+      account: { cookies: COOKIE, username: "alice" },
+    });
+    expect((await a.authenticate({})).account).toBe("alice");
+  });
+
+  it("cookie mode takes precedence over file-import", async () => {
+    const a = new Train12306Adapter({
+      account: { cookies: COOKIE },
+      dataPath: "x.json",
+    });
+    expect((await a.authenticate({})).mode).toBe("cookie");
+  });
+});
+
+describe("sync — cookie-api mode", () => {
+  it("yields flattened ticket events from completed + pending", async () => {
+    const calls = [];
+    const fetchFn = async ({ url, cookies, form }) => {
+      calls.push({ url, cookies, form });
+      if (url.includes("NoComplete")) {
+        return { data: { orderDBList: [rawOrder("PEND1")] } };
+      }
+      // single completed page (< PAGE_SIZE → stops)
+      return { data: { OrderDTODataList: [rawOrder("SEQ1")] } };
+    };
+    const a = new Train12306Adapter({ account: { cookies: COOKIE }, fetchFn });
+    const items = await collect(a.sync({}));
+    expect(items.map((i) => i.originalId)).toEqual([
+      "12306:ticket:ticket-SEQ1:0",
+      "12306:ticket:ticket-PEND1:0",
+    ]);
+    expect(items[0].payload.snapshot).toBe(true);
+    expect(items[0].payload.capturedVia).toBe("cookie-api");
+    expect(items[1].payload.isCompleted).toBe(false);
+    // cookie header forwarded + completed form carries pagination params
+    expect(calls[0].cookies).toBe(COOKIE);
+    expect(calls[0].form).toMatchObject({
+      come_from_flag: "my_order",
+      pageSize: "50",
+      pageIndex: "1",
+    });
+  });
+
+  it("paginates completed orders until a short page", async () => {
+    const fetchFn = async ({ url, form }) => {
+      if (url.includes("NoComplete")) return { data: { orderDBList: [] } };
+      const page = parseInt(form.pageIndex, 10);
+      if (page === 1) {
+        // exactly PAGE_SIZE (50) → triggers page 2
+        const orders = Array.from({ length: 50 }, (_, i) => rawOrder(`P1-${i}`));
+        return { data: { OrderDTODataList: orders } };
+      }
+      if (page === 2) return { data: { OrderDTODataList: [rawOrder("P2-0")] } };
+      return { data: { OrderDTODataList: [] } };
+    };
+    const a = new Train12306Adapter({ account: { cookies: COOKIE }, fetchFn });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(51); // 50 + 1, then short page stops
+  });
+
+  it("honors limit + include gate", async () => {
+    const fetchFn = async ({ url }) =>
+      url.includes("NoComplete")
+        ? { data: { orderDBList: [] } }
+        : { data: { OrderDTODataList: [rawOrder("A"), rawOrder("B")] } };
+    const a = new Train12306Adapter({ account: { cookies: COOKIE }, fetchFn });
+    expect(await collect(a.sync({ limit: 1 }))).toHaveLength(1);
+    expect(await collect(a.sync({ include: { ticket: false } }))).toHaveLength(0);
+  });
+
+  it("empty responses yield nothing (expired cookie / no orders)", async () => {
+    const fetchFn = async () => ({});
+    const a = new Train12306Adapter({ account: { cookies: COOKIE }, fetchFn });
+    expect(await collect(a.sync({}))).toHaveLength(0);
+  });
+
+  it("throws when cookie mode active but no fetchFn injected", async () => {
+    const a = new Train12306Adapter({ account: { cookies: COOKIE } });
+    await expect(collect(a.sync({}))).rejects.toThrow(/no fetchFn configured/);
+  });
+
+  it("normalize maps a cookie ticket event → trip with capturedVia", async () => {
+    const fetchFn = async ({ url }) =>
+      url.includes("NoComplete")
+        ? { data: { orderDBList: [] } }
+        : { data: { OrderDTODataList: [rawOrder("SEQ1")] } };
+    const a = new Train12306Adapter({ account: { cookies: COOKIE }, fetchFn });
+    const [item] = await collect(a.sync({}));
+    const batch = a.normalize(item);
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("trip");
+    expect(ev.content.title).toBe("train: 上海虹桥 → 北京南");
+    expect(ev.extra.vendorExtras).toMatchObject({
+      capturedVia: "cookie-api",
+      idLast6: "011234",
+    });
+  });
+});

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);
+    }
+  });
+});

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

@@ -0,0 +1,204 @@
+"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 {
+  DidiAdapter,
+  parseRecords,
+  orderToRecord,
+  extractOrders,
+  parseFareYuan,
+  NAME,
+  VERSION,
+} = require("../../lib/adapters/travel-didi");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-didi-${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 = "es_token=abc; ticket=xyz";
+
+const RIDE = {
+  orderId: "DD1",
+  fromAddress: "公司",
+  toAddress: "机场",
+  departTime: 1716383021000,
+  arriveTime: 1716386021000,
+  fare: "58.50",
+  productName: "专车",
+  passengerName: "张三",
+};
+
+describe("constants + parseFareYuan", () => {
+  it("exposes name/version", () => {
+    expect(NAME).toBe("travel-didi");
+    expect(VERSION).toBe("0.1.0");
+  });
+  it("parseFareYuan: 元 decimal kept; large integer treated as 分", () => {
+    expect(parseFareYuan("58.50")).toBe(58.5);
+    expect(parseFareYuan(58.5)).toBe(58.5);
+    expect(parseFareYuan(5850)).toBe(58.5); // 分
+    expect(parseFareYuan(58)).toBe(58); // small int → 元
+    expect(parseFareYuan("x")).toBe(0);
+  });
+});
+
+describe("orderToRecord", () => {
+  it("maps a ride → car TravelRecord (from/to name, fare, product)", () => {
+    const rec = orderToRecord(RIDE, { capturedVia: "cookie-api" });
+    expect(rec).toMatchObject({
+      vendorId: "didi",
+      recordId: "DD1",
+      vehicleType: "car",
+      from: { name: "公司" },
+      to: { name: "机场" },
+      departureMs: 1716383021000,
+      arrivalMs: 1716386021000,
+      carrier: "滴滴",
+      traveler: "张三",
+    });
+    expect(rec.totalCost).toEqual({ value: 58.5, currency: "CNY" });
+    expect(rec.extras.productType).toBe("专车");
+    expect(rec.extras.capturedVia).toBe("cookie-api");
+  });
+  it("snake_case + seconds-epoch aliases; drops id-less", () => {
+    const rec = orderToRecord({ oid: "DD2", from_address: "A", to_address: "B", depart_time: 1716383021, total_fee: 5850 });
+    expect(rec.recordId).toBe("DD2");
+    expect(rec.departureMs).toBe(1716383021000); // seconds → ms
+    expect(rec.totalCost.value).toBe(58.5);
+    expect(orderToRecord({ from_address: "A" })).toBe(null);
+  });
+  it("extractOrders tolerant of shapes", () => {
+    expect(extractOrders({ orders: [{ orderId: 1 }] })).toHaveLength(1);
+    expect(extractOrders({ data: { list: [{ orderId: 1 }] } })).toHaveLength(1);
+    expect(extractOrders({})).toEqual([]);
+  });
+});
+
+describe("DidiAdapter file/snapshot mode", () => {
+  it("authenticate ready without account; validates inputPath", async () => {
+    const a = new DidiAdapter();
+    expect(await a.authenticate({})).toEqual({ ok: true, account: null, mode: "ready" });
+    const p = writeTmp("[]");
+    try {
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      expect((await a.authenticate({ inputPath: path.join(os.tmpdir(), "nope-dd.json") })).reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync yields ride + normalize end-to-end (car trip)", async () => {
+    const p = writeTmp(JSON.stringify([RIDE]));
+    try {
+      const a = new DidiAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      expect(items[0]).toMatchObject({ adapter: NAME, originalId: "DD1" });
+      const batch = a.normalize(items[0]);
+      expect(batch.events[0].content.title).toBe("car: 公司 → 机场");
+      expect(batch.events[0].content.amount).toEqual({ value: 58.5, currency: "CNY", direction: "out" });
+      expect(batch.persons.find((x) => x.subtype === "merchant").names).toEqual(["滴滴"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("parseRecords JSONL + {orders} envelope; sync silent when no path", async () => {
+    expect(parseRecords(JSON.stringify({ orders: [RIDE] }))).toHaveLength(1);
+    const jsonl = `${JSON.stringify(RIDE)}\njunk\n${JSON.stringify({ ...RIDE, orderId: "DD9" })}`;
+    expect(parseRecords(jsonl).map((r) => r.recordId)).toEqual(["DD1", "DD9"]);
+    const a = new DidiAdapter();
+    expect(await collect(a.sync({}))).toEqual([]);
+  });
+
+  it("normalize throws on missing record", () => {
+    const a = new DidiAdapter();
+    expect(() => a.normalize({ payload: {} })).toThrow(/payload\.record missing/);
+  });
+});
+
+describe("DidiAdapter cookie-api mode", () => {
+  it("authenticate cookie mode (account optional)", async () => {
+    const a = new DidiAdapter({ account: { cookies: COOKIES } });
+    expect(await a.authenticate()).toEqual({ ok: true, account: null, mode: "cookie" });
+    const ready = new DidiAdapter({ account: { cookies: "" } });
+    expect((await ready.authenticate()).mode).toBe("ready");
+  });
+
+  it("sync fetches, paginates, maps + normalizes", async () => {
+    const pages = [
+      { data: { list: [{ orderId: "CK1", fromAddress: "家", toAddress: "公司", departTime: 1716383021, fare: 2300 }] } },
+      { data: { list: [] } },
+    ];
+    const calls = [];
+    const fetchFn = async ({ url, cookies, query, sign }) => {
+      calls.push({ url, cookies, pageIndex: query.pageIndex, sign });
+      return pages[query.pageIndex - 1] || { data: { list: [] } };
+    };
+    const a = new DidiAdapter({ account: { cookies: COOKIES }, 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.title).toBe("car: 家 → 公司");
+    expect(batch.events[0].content.amount.value).toBe(23); // 2300 分 → 23 元
+  });
+
+  it("invokes signProvider when configured", async () => {
+    const signCalls = [];
+    const a = new DidiAdapter({
+      account: { cookies: COOKIES },
+      fetchFn: async ({ query }) => (query.pageIndex === 1 ? { orders: [{ orderId: "S1" }] } : { orders: [] }),
+      signProvider: async (ctx) => { signCalls.push(ctx); return "DD-SIG"; },
+    });
+    const items = await collect(a.sync({ sinceWatermark: 0 }));
+    expect(items).toHaveLength(1);
+    expect(signCalls.length).toBeGreaterThan(0);
+    expect(signCalls[0].cookies).toBe(COOKIES);
+  });
+
+  it("sinceWatermark + limit + empty/login response + default fetch throws", async () => {
+    const a1 = new DidiAdapter({
+      account: { cookies: COOKIES },
+      fetchFn: async () => ({ orders: [
+        { orderId: "NEW", departTime: 2_000_000_000_000 },
+        { orderId: "OLD", departTime: 1_000_000_000_000 },
+      ] }),
+    });
+    expect((await collect(a1.sync({ sinceWatermark: 1_500_000_000_000, maxPages: 1 }))).map((x) => x.originalId)).toEqual(["NEW"]);
+
+    const a2 = new DidiAdapter({ account: { cookies: COOKIES }, fetchFn: async () => "<html>login</html>" });
+    expect(await collect(a2.sync({ sinceWatermark: 0 }))).toEqual([]);
+
+    const a3 = new DidiAdapter({ account: { cookies: COOKIES } });
+    await expect(collect(a3.sync({ sinceWatermark: 0 }))).rejects.toThrow(/no fetchFn configured/);
+  });
+
+  it("file path takes priority over cookie mode", async () => {
+    const p = writeTmp(JSON.stringify([RIDE]));
+    try {
+      const a = new DidiAdapter({
+        account: { cookies: COOKIES },
+        fetchFn: async () => { throw new Error("must not fetch in file mode"); },
+      });
+      expect((await collect(a.sync({ inputPath: p }))).map((x) => x.originalId)).toEqual(["DD1"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+});