@chainlesschain/personal-data-hub 0.4.2 → 0.4.4

package/__tests__/adapters/travel-baidu-map.test.js

@@ -0,0 +1,305 @@
+"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 {
+  BaiduMapAdapter,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/travel-baidu-map");
+
+function writeTmp(content, ext = "json") {
+  const p = path.join(
+    os.tmpdir(),
+    `cc-baidumap-test-${crypto.randomUUID()}.${ext}`,
+  );
+  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;
+}
+
+function makeFakeDriverFactory(tables, log = {}) {
+  return () =>
+    class FakeDb {
+      constructor(dbPath, opts) {
+        log.opened = { dbPath, opts };
+      }
+      prepare(sql) {
+        for (const [needle, rows] of Object.entries(tables)) {
+          if (sql.includes(needle)) return { all: () => rows };
+        }
+        throw new Error(`no such table in: ${sql}`);
+      }
+      close() {
+        log.closed = true;
+      }
+    };
+}
+
+const SNAPSHOT = {
+  schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+  snapshottedAt: 1716383021000,
+  vendor: "baidu-map",
+  account: { uid: "U1", displayName: "Alice" },
+  events: [
+    {
+      kind: "favourite",
+      id: "fav-1",
+      capturedAt: 1716383021000,
+      name: "家",
+      address: "幸福路1号",
+      lat: 31.23,
+      lng: 121.47,
+      category: "home",
+    },
+    {
+      kind: "search",
+      id: "search-2",
+      time: 1716383021, // seconds — parseTime must upgrade to ms
+      query: "咖啡店",
+      city: "上海",
+    },
+    {
+      kind: "route",
+      id: "route-3",
+      capturedAt: 1716383021000,
+      from: { name: "家", lat: 31.23, lng: 121.47 },
+      to: { name: "公司", lat: 31.2, lng: 121.44 },
+      mode: "drive",
+    },
+    { kind: "alien", id: "x" },
+  ],
+};
+
+describe("constants", () => {
+  it("exposes name/version/schema", () => {
+    expect(NAME).toBe("travel-baidu-map");
+    expect(VERSION).toBe("0.6.0");
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+});
+
+describe("authenticate", () => {
+  it("snapshot mode ok / unreadable", async () => {
+    const p = writeTmp("{}");
+    try {
+      const a = new BaiduMapAdapter();
+      expect(await a.authenticate({ inputPath: p })).toEqual({
+        ok: true,
+        mode: "snapshot-file",
+      });
+      const bad = await a.authenticate({
+        inputPath: path.join(os.tmpdir(), "nonexistent-baidu.json"),
+      });
+      expect(bad.reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sqlite mode requires account.deviceId; NO_INPUT otherwise", async () => {
+    const noAcc = new BaiduMapAdapter({ dbPath: "x.db" });
+    expect((await noAcc.authenticate({})).reason).toBe("NO_ACCOUNT_DEVICE_ID");
+    const withAcc = new BaiduMapAdapter({
+      dbPath: "x.db",
+      account: { deviceId: "DEV1" },
+    });
+    expect(await withAcc.authenticate({})).toEqual({
+      ok: true,
+      account: "DEV1",
+      mode: "sqlite",
+    });
+    expect((await new BaiduMapAdapter().authenticate({})).reason).toBe(
+      "NO_INPUT",
+    );
+  });
+});
+
+describe("sync — snapshot mode", () => {
+  it("yields 3 kinds with prefixed originalId + account attached, skips unknown kind", async () => {
+    const p = writeTmp(JSON.stringify(SNAPSHOT));
+    try {
+      const a = new BaiduMapAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(3);
+      expect(items.map((i) => i.originalId)).toEqual([
+        "baidu-map:favourite:fav-1",
+        "baidu-map:search:search-2",
+        "baidu-map:route:route-3",
+      ]);
+      // every payload carries the snapshot account for bookkeeping
+      for (const i of items) {
+        expect(i.payload.account).toEqual({ uid: "U1", displayName: "Alice" });
+      }
+      // ev.time in seconds upgraded to ms
+      expect(items[1].capturedAt).toBe(1716383021 * 1000);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("throws on schemaVersion mismatch; honors include gate + limit", async () => {
+    const bad = writeTmp(JSON.stringify({ schemaVersion: 9, events: [] }));
+    const good = writeTmp(JSON.stringify(SNAPSHOT));
+    try {
+      const a = new BaiduMapAdapter();
+      await expect(collect(a.sync({ inputPath: bad }))).rejects.toThrow(
+        /schemaVersion mismatch/,
+      );
+      expect(
+        await collect(a.sync({ inputPath: good, include: { search: false } })),
+      ).toHaveLength(2);
+      expect(
+        await collect(a.sync({ inputPath: good, limit: 1 })),
+      ).toHaveLength(1);
+    } finally {
+      fs.unlinkSync(bad);
+      fs.unlinkSync(good);
+    }
+  });
+});
+
+describe("sync — sqlite mode (fake driver)", () => {
+  const ROUTE_ROW = {
+    _id: 5,
+    type: "transit",
+    start_name: "人民广场",
+    end_name: "虹桥火车站",
+    start_lat: 31.23,
+    start_lng: 121.47,
+    time: 1716383021, // seconds
+  };
+  const SEARCH_ROW = { _id: 6, key: "火锅", city: "成都", time: "1716383021" };
+
+  it("requires account.deviceId", async () => {
+    const a = new BaiduMapAdapter({ dbPath: "x.db" });
+    await expect(collect(a.sync({}))).rejects.toThrow(
+      /account\.deviceId required/,
+    );
+  });
+
+  it("yields route (transit→bus) + search records, closes db", async () => {
+    const p = writeTmp("fake", "db");
+    const log = {};
+    try {
+      const a = new BaiduMapAdapter({
+        dbPath: p,
+        account: { deviceId: "DEV1" },
+        dbDriverFactory: makeFakeDriverFactory(
+          { route_history: [ROUTE_ROW], search_history: [SEARCH_ROW] },
+          log,
+        ),
+      });
+      const items = await collect(a.sync({}));
+      expect(items).toHaveLength(2);
+      expect(items[0].payload.record).toMatchObject({
+        vendorId: "baidumap",
+        recordId: "route-5",
+        vehicleType: "bus",
+        carrier: "百度地图",
+        departureMs: 1716383021 * 1000,
+      });
+      expect(items[1].payload.record).toMatchObject({
+        recordId: "search-6",
+        vehicleType: "visit",
+        departureMs: 1716383021 * 1000, // string seconds upgraded
+      });
+      expect(items[1].payload.record.to).toMatchObject({
+        name: "火锅",
+        city: "成都",
+      });
+      expect(log.opened.opts).toEqual({ readonly: true });
+      expect(log.closed).toBe(true);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("falls back to bd_route_history legacy table; missing db file silent", async () => {
+    const p = writeTmp("fake", "db");
+    try {
+      const a = new BaiduMapAdapter({
+        dbPath: p,
+        account: { deviceId: "DEV1" },
+        dbDriverFactory: makeFakeDriverFactory({
+          bd_route_history: [ROUTE_ROW],
+          search_history: [],
+        }),
+      });
+      expect(await collect(a.sync({}))).toHaveLength(1);
+
+      const gone = new BaiduMapAdapter({
+        dbPath: path.join(os.tmpdir(), "nonexistent-baidu.db"),
+        account: { deviceId: "DEV1" },
+        dbDriverFactory: makeFakeDriverFactory({}),
+      });
+      expect(await collect(gone.sync({}))).toEqual([]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+});
+
+describe("normalize", () => {
+  it("snapshot favourite → visit trip titled by place name", async () => {
+    const p = writeTmp(JSON.stringify(SNAPSHOT));
+    try {
+      const a = new BaiduMapAdapter();
+      const [fav, search, route] = await collect(a.sync({ inputPath: p }));
+
+      const favBatch = a.normalize(fav);
+      expect(favBatch.events[0].subtype).toBe("trip");
+      expect(favBatch.events[0].content.title).toBe("visit: → 家");
+      expect(favBatch.events[0].extra.vendorExtras.category).toBe("home");
+      expect(favBatch.places[0].coordinates).toEqual({
+        lat: 31.23,
+        lng: 121.47,
+      });
+
+      // search has city → city wins over name in the title
+      expect(a.normalize(search).events[0].content.title).toBe("visit: → 上海");
+
+      const routeBatch = a.normalize(route);
+      expect(routeBatch.events[0].content.title).toBe("car: 家 → 公司");
+      expect(routeBatch.places).toHaveLength(2);
+      const merchant = routeBatch.persons.find((x) => x.subtype === "merchant");
+      expect(merchant.names).toEqual(["百度地图"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sqlite-mode record payload passes through travel-base", () => {
+    const a = new BaiduMapAdapter();
+    const batch = a.normalize({
+      payload: {
+        record: {
+          vendorId: "baidumap",
+          recordId: "route-9",
+          vehicleType: "car",
+          from: { name: "A" },
+          to: { name: "B" },
+          carrier: "百度地图",
+        },
+        kind: "route",
+      },
+    });
+    expect(batch.events[0].content.title).toBe("car: A → B");
+  });
+
+  it("throws on missing payload", () => {
+    expect(() => new BaiduMapAdapter().normalize(null)).toThrow(
+      /payload missing/,
+    );
+  });
+});

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

@@ -0,0 +1,205 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  normalizeTravelRecord,
+  parseChineseDateTime,
+  placeIdFor,
+  slug,
+} = require("../../lib/adapters/travel-base");
+
+describe("normalizeTravelRecord", () => {
+  const fullRecord = {
+    vendorId: "12306",
+    recordId: "E123456789",
+    vehicleType: "train",
+    from: { station: "上海虹桥", city: "上海" },
+    to: { station: "北京南", city: "北京" },
+    departureMs: 1716383021000,
+    arrivalMs: 1716401021000,
+    carrier: "12306",
+    vehicleNumber: "G35",
+    totalCost: { value: 553.5, currency: "CNY" },
+    traveler: "张三",
+    confirmationCode: "E123456789",
+    bookedAt: 1716000000000,
+    extras: { seat: "二等座" },
+  };
+
+  it("throws without rec / recordId", () => {
+    expect(() => normalizeTravelRecord(null)).toThrow(/rec required/);
+    expect(() => normalizeTravelRecord({})).toThrow(/recordId required/);
+  });
+
+  it("emits 1 trip event with title, amount, vehicle metadata", () => {
+    const batch = normalizeTravelRecord(fullRecord, {
+      adapterName: "travel-12306",
+      adapterVersion: "0.6.0",
+    });
+    expect(batch.events).toHaveLength(1);
+    const ev = batch.events[0];
+    expect(ev.type).toBe("event");
+    expect(ev.subtype).toBe("trip");
+    expect(ev.occurredAt).toBe(1716383021000); // departureMs wins
+    expect(ev.content.title).toBe("train: 上海虹桥 → 北京南");
+    expect(ev.content.amount).toEqual({
+      value: 553.5,
+      currency: "CNY",
+      direction: "out",
+    });
+    expect(ev.source).toMatchObject({
+      adapter: "travel-12306",
+      adapterVersion: "0.6.0",
+      originalId: "E123456789",
+    });
+    expect(ev.extra).toMatchObject({
+      vehicleType: "train",
+      vendorId: "12306",
+      from: "上海虹桥",
+      to: "北京南",
+      vehicleNumber: "G35",
+      confirmationCode: "E123456789",
+      arrivalMs: 1716401021000,
+      bookedAt: 1716000000000,
+    });
+  });
+
+  it("emits from/to places with stable dedup-able ids", () => {
+    const batch = normalizeTravelRecord(fullRecord, {
+      adapterName: "travel-12306",
+    });
+    expect(batch.places).toHaveLength(2);
+    expect(batch.places[0].name).toBe("上海虹桥");
+    expect(batch.places[0].type).toBe("place");
+    // same station on another trip → same place id (cross-trip dedup)
+    const again = normalizeTravelRecord(
+      { ...fullRecord, recordId: "OTHER" },
+      { adapterName: "travel-12306" },
+    );
+    expect(again.places[0].id).toBe(batch.places[0].id);
+  });
+
+  it("emits carrier as merchant person + traveler as contact person", () => {
+    const batch = normalizeTravelRecord(fullRecord, {
+      adapterName: "travel-12306",
+    });
+    const merchant = batch.persons.find((p) => p.subtype === "merchant");
+    const contact = batch.persons.find((p) => p.subtype === "contact");
+    expect(merchant.names).toEqual(["12306"]);
+    expect(contact.names).toEqual(["张三"]);
+    // traveler becomes the actor; self + traveler + carrier participate
+    const ev = batch.events[0];
+    expect(ev.actor).toBe(contact.id);
+    expect(ev.participants).toEqual(["person-self", contact.id, merchant.id]);
+  });
+
+  it("suppresses traveler person when traveler is self", () => {
+    const batch = normalizeTravelRecord(fullRecord, {
+      adapterName: "travel-12306",
+      selfName: "张三",
+    });
+    expect(batch.persons.find((p) => p.subtype === "contact")).toBeUndefined();
+    expect(batch.events[0].actor).toBe("person-self");
+  });
+
+  it("falls back occurredAt: departureMs → bookedAt → now", () => {
+    const noDeparture = normalizeTravelRecord({
+      recordId: "R1",
+      bookedAt: 1716000000000,
+    });
+    expect(noDeparture.events[0].occurredAt).toBe(1716000000000);
+    const before = Date.now();
+    const bare = normalizeTravelRecord({ recordId: "R2" });
+    expect(bare.events[0].occurredAt).toBeGreaterThanOrEqual(before);
+  });
+
+  it("builds partial titles when from/to missing", () => {
+    const toOnly = normalizeTravelRecord({
+      recordId: "R1",
+      vehicleType: "visit",
+      to: { name: "咖啡店" },
+    });
+    expect(toOnly.events[0].content.title).toBe("visit: → 咖啡店");
+    const neither = normalizeTravelRecord({
+      recordId: "R2",
+      carrier: "高德地图",
+    });
+    expect(neither.events[0].content.title).toBe("trip: 高德地图");
+  });
+
+  it("omits amount when totalCost.value not finite", () => {
+    const batch = normalizeTravelRecord({
+      recordId: "R1",
+      totalCost: { value: NaN },
+    });
+    expect(batch.events[0].content.amount).toBeUndefined();
+  });
+});
+
+describe("parseChineseDateTime", () => {
+  it("parses YYYY-MM-DD HH:MM:SS (local time)", () => {
+    expect(parseChineseDateTime("2026-04-15 14:30:00")).toBe(
+      new Date(2026, 3, 15, 14, 30, 0).getTime(),
+    );
+  });
+
+  it("parses YYYY/MM/DD HH:MM", () => {
+    expect(parseChineseDateTime("2026/4/15 14:30")).toBe(
+      new Date(2026, 3, 15, 14, 30).getTime(),
+    );
+  });
+
+  it("parses 2026年4月15日 14:30", () => {
+    expect(parseChineseDateTime("2026年4月15日 14:30")).toBe(
+      new Date(2026, 3, 15, 14, 30).getTime(),
+    );
+  });
+
+  it("parses 2026年4月15日 (date only)", () => {
+    expect(parseChineseDateTime("2026年4月15日")).toBe(
+      new Date(2026, 3, 15).getTime(),
+    );
+  });
+
+  it("parses ISO-with-Z via the first regex AS LOCAL TIME (documented quirk)", () => {
+    // The YYYY-MM-DD[T ]HH:MM regex matches before the Date.parse fallback
+    // and ignores the Z suffix — Chinese app dumps are local-time anyway.
+    expect(parseChineseDateTime("2026-04-15T06:30:00.000Z")).toBe(
+      new Date(2026, 3, 15, 6, 30, 0).getTime(),
+    );
+  });
+
+  it("falls back to Date.parse for formats no regex matches", () => {
+    expect(parseChineseDateTime("Apr 15, 2026")).toBe(
+      Date.parse("Apr 15, 2026"),
+    );
+  });
+
+  it("returns null for garbage / empty / non-string", () => {
+    expect(parseChineseDateTime("not a date")).toBe(null);
+    expect(parseChineseDateTime("")).toBe(null);
+    expect(parseChineseDateTime(42)).toBe(null);
+  });
+});
+
+describe("placeIdFor + slug", () => {
+  it("keys by station first, lowercased + slugged", () => {
+    expect(placeIdFor({ station: "北京南", city: "北京" }, "travel-12306")).toBe(
+      "place-travel-12306-北京南",
+    );
+    expect(placeIdFor({ city: "Shanghai HongQiao" }, "a")).toBe(
+      "place-a-shanghai-hongqiao",
+    );
+  });
+
+  it("returns null for empty place", () => {
+    expect(placeIdFor(null, "a")).toBe(null);
+  });
+
+  it("slug strips punctuation, keeps CJK + word chars + dash", () => {
+    expect(slug("高德地图")).toBe("高德地图");
+    expect(slug("Air China! (CA)")).toBe("air-china-ca");
+    expect(slug("")).toBe("");
+  });
+});

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

@@ -0,0 +1,203 @@
+"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 {
+  CtripAdapter,
+  parseRecords,
+  TYPE_MAP,
+  NAME,
+  VERSION,
+} = require("../../lib/adapters/travel-ctrip");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-ctrip-test-${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 FLIGHT_ORDER = {
+  orderId: "CT1",
+  type: "flight",
+  fromCity: "上海",
+  toCity: "北京",
+  departureTime: 1716383021000,
+  arrivalTime: 1716390000000,
+  airline: "国航",
+  flightNumber: "CA1234",
+  price: "1280.00",
+  passengerName: "张三",
+  pnr: "ABC123",
+};
+
+describe("constants + TYPE_MAP", () => {
+  it("exposes name/version", () => {
+    expect(NAME).toBe("travel-ctrip");
+    expect(VERSION).toBe("0.6.0");
+  });
+
+  it("maps ctrip order types to vehicleType", () => {
+    expect(TYPE_MAP.flight).toBe("flight");
+    expect(TYPE_MAP.airline).toBe("flight");
+    expect(TYPE_MAP.hotel).toBe("hotel");
+    expect(TYPE_MAP.train).toBe("train");
+    expect(TYPE_MAP.cruise).toBe("cruise");
+  });
+});
+
+describe("parseRecords", () => {
+  it("parses flight order with aliases (airline → carrier, pnr → confirmation)", () => {
+    const recs = parseRecords(JSON.stringify([FLIGHT_ORDER]));
+    expect(recs).toHaveLength(1);
+    expect(recs[0]).toMatchObject({
+      vendorId: "ctrip",
+      recordId: "CT1",
+      vehicleType: "flight",
+      from: { city: "上海" },
+      to: { city: "北京" },
+      departureMs: 1716383021000,
+      carrier: "国航",
+      vehicleNumber: "CA1234",
+      traveler: "张三",
+      confirmationCode: "ABC123",
+    });
+    expect(recs[0].totalCost).toEqual({ value: 1280, currency: "CNY" });
+  });
+
+  it("hotel order: hotelCity → to, hotelName → carrier, checkIn/Out → times", () => {
+    const recs = parseRecords(
+      JSON.stringify([
+        {
+          id: "H1",
+          type: "hotel",
+          hotelCity: "杭州",
+          hotelName: "西湖宾馆",
+          checkIn: "2026年4月15日",
+          checkOut: "2026年4月17日",
+          guestName: "李四",
+          nights: 2,
+        },
+      ]),
+    );
+    expect(recs[0]).toMatchObject({
+      recordId: "H1",
+      vehicleType: "hotel",
+      to: { city: "杭州" },
+      carrier: "西湖宾馆",
+      traveler: "李四",
+    });
+    expect(recs[0].from).toBe(null);
+    expect(recs[0].departureMs).toBe(new Date(2026, 3, 15).getTime());
+    expect(recs[0].extras.nights).toBe(2);
+  });
+
+  it("unknown type falls back to trip + default carrier 携程", () => {
+    const recs = parseRecords(JSON.stringify([{ order_no: "X1" }]));
+    expect(recs[0].vehicleType).toBe("trip");
+    expect(recs[0].carrier).toBe("携程");
+  });
+
+  it("accepts {orders:[...]} envelope + JSONL fallback, drops id-less rows", () => {
+    expect(
+      parseRecords(JSON.stringify({ orders: [FLIGHT_ORDER] })),
+    ).toHaveLength(1);
+    const jsonl = `${JSON.stringify(FLIGHT_ORDER)}\ngarbage line\n${JSON.stringify({ ...FLIGHT_ORDER, orderId: "CT2" })}`;
+    expect(parseRecords(jsonl).map((r) => r.recordId)).toEqual(["CT1", "CT2"]);
+    expect(parseRecords(JSON.stringify([{ type: "flight" }]))).toHaveLength(0);
+  });
+});
+
+describe("CtripAdapter", () => {
+  it("authenticate ok in ready mode without account (v0.6 optional)", async () => {
+    const a = new CtripAdapter();
+    expect(await a.authenticate({})).toEqual({
+      ok: true,
+      account: null,
+      mode: "ready",
+    });
+  });
+
+  it("authenticate validates inputPath readability", async () => {
+    const p = writeTmp("[]");
+    try {
+      const a = new CtripAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe(
+        "snapshot-file",
+      );
+      const bad = await a.authenticate({
+        inputPath: path.join(os.tmpdir(), "nonexistent-ctrip.json"),
+      });
+      expect(bad.ok).toBe(false);
+      expect(bad.reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync yields orders from file (inputPath alias) + normalize end-to-end", async () => {
+    const p = writeTmp(JSON.stringify([FLIGHT_ORDER]));
+    try {
+      const a = new CtripAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      expect(items[0]).toMatchObject({ adapter: NAME, originalId: "CT1" });
+      const batch = a.normalize(items[0]);
+      const ev = batch.events[0];
+      expect(ev.subtype).toBe("trip");
+      expect(ev.content.title).toBe("flight: 上海 → 北京");
+      expect(ev.content.amount).toEqual({
+        value: 1280,
+        currency: "CNY",
+        direction: "out",
+      });
+      expect(
+        batch.persons.find((x) => x.subtype === "merchant").names,
+      ).toEqual(["国航"]);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync returns silently when no path / missing file", async () => {
+    const a = new CtripAdapter();
+    expect(await collect(a.sync({}))).toEqual([]);
+    expect(
+      await collect(
+        a.sync({ inputPath: path.join(os.tmpdir(), "nope-ctrip.json") }),
+      ),
+    ).toEqual([]);
+  });
+
+  it("sync throws on broken {-line; pure garbage degrades to empty (JSONL filter)", async () => {
+    const broken = writeTmp("{broken json line");
+    const garbage = writeTmp("not json at all");
+    try {
+      const a = new CtripAdapter();
+      await expect(collect(a.sync({ inputPath: broken }))).rejects.toThrow(
+        /parse failed/,
+      );
+      // no line starts with "{" → JSONL filter yields [] rather than throwing
+      expect(await collect(a.sync({ inputPath: garbage }))).toEqual([]);
+    } finally {
+      fs.unlinkSync(broken);
+      fs.unlinkSync(garbage);
+    }
+  });
+
+  it("normalize throws on missing record", () => {
+    const a = new CtripAdapter();
+    expect(() => a.normalize({ payload: {} })).toThrow(
+      /payload\.record missing/,
+    );
+  });
+});