@chainlesschain/personal-data-hub 0.4.28 → 0.4.30

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

@@ -1,205 +0,0 @@
-"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

@@ -1,377 +0,0 @@
-"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,
-  orderToRecord,
-  extractOrders,
-  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.7.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/,
-    );
-  });
-});
-
-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-consumer.test.js

@@ -1,66 +0,0 @@
-"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 dc = require("../../lib/adapters/travel-didi-consumer");
-
-function writeTmp(content) {
-  const p = path.join(os.tmpdir(), `cc-didic-${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 = "didi_token=abc";
-
-describe("travel-didi-consumer", () => {
-  it("name distinct from enterprise", () => {
-    expect(dc.NAME).toBe("travel-didi-consumer");
-    expect(new dc.DidiConsumerAdapter().name).toBe("travel-didi-consumer");
-  });
-
-  it("snapshot ride → car travel event (via travel-base normalize)", async () => {
-    const SNAP = JSON.stringify([
-      { orderId: "O1", fromAddress: "家", toAddress: "公司", departTime: 1716383000, arriveTime: 1716385000, fare: 2350, productName: "快车" },
-    ]);
-    const p = writeTmp(SNAP);
-    try {
-      const a = new dc.DidiConsumerAdapter();
-      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
-      const items = await collect(a.sync({ inputPath: p }));
-      expect(items).toHaveLength(1);
-      expect(items[0].originalId).toBe("O1");
-      const b = a.normalize(items[0]);
-      expect(b.events.length).toBeGreaterThan(0);
-      expect(b.source ? true : b.events[0].source.adapter).toBe("travel-didi-consumer");
-    } finally {
-      fs.unlinkSync(p);
-    }
-  });
-
-  it("cookie-api: unverified + sign seam + paginate", async () => {
-    let signed = 0;
-    const a = new dc.DidiConsumerAdapter({
-      account: { cookies: COOKIES, phone: "1" },
-      signProvider: async () => { signed += 1; return "sig"; },
-      fetchFn: async ({ query }) => (query.pageIndex > 1 ? { data: { list: [] } } : { data: { list: [{ orderId: "O9", fromAddress: "A", toAddress: "B", departTime: Date.now() }] } }),
-    });
-    expect(await a.authenticate()).toMatchObject({ ok: true, mode: "cookie", unverified: true });
-    const items = await collect(a.sync({}));
-    expect(items).toHaveLength(1);
-    expect(items[0].originalId).toBe("O9");
-    expect(signed).toBeGreaterThan(0);
-  });
-
-  it("medium sensitivity; default fetch throws", async () => {
-    expect(new dc.DidiConsumerAdapter().dataDisclosure.sensitivity).toBe("medium");
-    await expect(collect(new dc.DidiConsumerAdapter({ account: { cookies: COOKIES } }).sync({}))).rejects.toThrow(/no fetchFn/);
-  });
-});