@chainlesschain/personal-data-hub 0.3.1 → 0.3.7

package/__tests__/adapters/social-bilibili-adb-chromium-cookies-reader.test.js

@@ -0,0 +1,346 @@
+"use strict";
+
+/**
+ * Phase 1a (Bilibili C 路径) — unit cover for the chromium-cookies-reader.
+ *
+ * Builds a real chromium-shape Cookies sqlite via better-sqlite3 (the
+ * test path that browser-history-chrome.test.js uses — root Node ABI
+ * 127 matches plain better-sqlite3, no FTS5 / encryption needed). All
+ * tests run in <1s on CI.
+ *
+ * Covered:
+ *  - hostKeyMatches across .domain / domain / subdomain / non-match
+ *  - readChromiumCookies filtering by domain
+ *  - Cookie schema column tolerance (encrypted_value / is_secure /
+ *    is_persistent missing — old or aggressively-pruned WebView builds)
+ *  - assembleBilibiliCookieHeader: complete / missing-required / dup-name
+ *  - encrypted_value rows skipped + diagnostic counter
+ *  - corrupted DB / wrong-schema DB → clear error
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import Database from "better-sqlite3";
+
+const {
+  readChromiumCookies,
+  assembleBilibiliCookieHeader,
+  BILIBILI_COOKIE_NAMES,
+  _internals,
+} = require("../../lib/adapters/social-bilibili-adb/chromium-cookies-reader");
+
+let tmpDir;
+let dbPath;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "cc-cookies-test-"));
+  dbPath = join(tmpDir, "Cookies");
+});
+
+afterEach(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore — temp cleanup is best-effort
+  }
+});
+
+/**
+ * Build a chromium-shape Cookies sqlite at [dbPath]. Optionally omit
+ * encrypted_value column (`{omitEncrypted: true}`) to simulate older
+ * Android WebView schemas that didn't have it.
+ */
+function buildCookiesFixture(rows, { omitEncrypted = false, omitSecure = false } = {}) {
+  const db = new Database(dbPath);
+  const cols = [
+    "creation_utc INTEGER",
+    "host_key TEXT",
+    "name TEXT",
+    "value TEXT",
+    omitEncrypted ? null : "encrypted_value BLOB",
+    "path TEXT",
+    "expires_utc INTEGER",
+    omitSecure ? null : "is_secure INTEGER",
+    "is_httponly INTEGER",
+    "is_persistent INTEGER",
+  ].filter(Boolean).join(", ");
+  db.exec(`CREATE TABLE cookies(${cols});`);
+  const params = [
+    "creation_utc",
+    "host_key",
+    "name",
+    "value",
+    omitEncrypted ? null : "encrypted_value",
+    "path",
+    "expires_utc",
+    omitSecure ? null : "is_secure",
+    "is_httponly",
+    "is_persistent",
+  ].filter(Boolean);
+  const placeholders = params.map(() => "?").join(", ");
+  const insert = db.prepare(
+    `INSERT INTO cookies(${params.join(", ")}) VALUES(${placeholders})`,
+  );
+  for (const r of rows) {
+    const values = [
+      r.creationUtc || 0,
+      r.hostKey,
+      r.name,
+      r.value || "",
+      ...(omitEncrypted ? [] : [r.encryptedValue || null]),
+      r.path || "/",
+      r.expiresUtc || 0,
+      ...(omitSecure ? [] : [r.isSecure ? 1 : 0]),
+      r.isHttpOnly ? 1 : 0,
+      r.isPersistent ? 1 : 0,
+    ];
+    insert.run(...values);
+  }
+  db.close();
+}
+
+// ─── hostKeyMatches ─────────────────────────────────────────────────────
+
+describe("hostKeyMatches", () => {
+  it("matches exact host_key against domain", () => {
+    expect(_internals.hostKeyMatches("bilibili.com", "bilibili.com")).toBe(true);
+  });
+
+  it("matches leading-dot host_key (most common)", () => {
+    expect(_internals.hostKeyMatches(".bilibili.com", "bilibili.com")).toBe(true);
+  });
+
+  it("matches subdomain host_key", () => {
+    expect(_internals.hostKeyMatches(".api.bilibili.com", "bilibili.com")).toBe(true);
+    expect(_internals.hostKeyMatches("api.bilibili.com", "bilibili.com")).toBe(true);
+  });
+
+  it("matches when both have leading dot", () => {
+    expect(_internals.hostKeyMatches(".bilibili.com", ".bilibili.com")).toBe(true);
+  });
+
+  it("rejects unrelated domain", () => {
+    expect(_internals.hostKeyMatches(".weibo.com", "bilibili.com")).toBe(false);
+  });
+
+  it("rejects partial-name collisions (bilibili.com.evil.cn)", () => {
+    // The domain check uses dot-anchored suffix, so foo.com matching
+    // foo.com.evil.cn is impossible.
+    expect(_internals.hostKeyMatches(".bilibili.com.evil.cn", "bilibili.com")).toBe(false);
+  });
+
+  it("rejects null / undefined / empty", () => {
+    expect(_internals.hostKeyMatches(null, "bilibili.com")).toBe(false);
+    expect(_internals.hostKeyMatches(".bilibili.com", null)).toBe(false);
+    expect(_internals.hostKeyMatches("", "bilibili.com")).toBe(false);
+  });
+});
+
+// ─── readChromiumCookies ────────────────────────────────────────────────
+
+describe("readChromiumCookies", () => {
+  it("returns only cookies matching the domain filter", () => {
+    buildCookiesFixture([
+      { hostKey: ".bilibili.com", name: "SESSDATA", value: "abc123" },
+      { hostKey: ".weibo.com", name: "SUB", value: "wbxx" },
+      { hostKey: ".bilibili.com", name: "bili_jct", value: "csrf456" },
+    ]);
+    const out = readChromiumCookies(dbPath, "bilibili.com");
+    expect(out).toHaveLength(2);
+    expect(out.map((r) => r.name).sort()).toEqual(["SESSDATA", "bili_jct"]);
+  });
+
+  it("handles subdomain-pinned cookies", () => {
+    buildCookiesFixture([
+      { hostKey: "api.bilibili.com", name: "PinnedCookie", value: "x" },
+      { hostKey: ".bilibili.com", name: "SESSDATA", value: "y" },
+    ]);
+    const out = readChromiumCookies(dbPath, "bilibili.com");
+    expect(out).toHaveLength(2);
+  });
+
+  it("skips encrypted_value rows + reports count", () => {
+    buildCookiesFixture([
+      { hostKey: ".bilibili.com", name: "SESSDATA", value: "plain" },
+      {
+        hostKey: ".bilibili.com",
+        name: "EncryptedThing",
+        value: "", // empty plaintext
+        encryptedValue: Buffer.from("garbled-bytes"),
+      },
+    ]);
+    const out = readChromiumCookies(dbPath, "bilibili.com");
+    expect(out).toHaveLength(1);
+    expect(out[0].name).toBe("SESSDATA");
+    expect(out._skippedEncryptedCount).toBe(1);
+  });
+
+  it("works on schema without encrypted_value column", () => {
+    buildCookiesFixture(
+      [{ hostKey: ".bilibili.com", name: "SESSDATA", value: "x" }],
+      { omitEncrypted: true },
+    );
+    const out = readChromiumCookies(dbPath, "bilibili.com");
+    expect(out).toHaveLength(1);
+    expect(out[0].hasEncryptedValue).toBe(false);
+  });
+
+  it("works on schema without is_secure column", () => {
+    buildCookiesFixture(
+      [{ hostKey: ".bilibili.com", name: "SESSDATA", value: "x" }],
+      { omitSecure: true },
+    );
+    const out = readChromiumCookies(dbPath, "bilibili.com");
+    expect(out[0].isSecure).toBe(false); // defaulted to 0 by COALESCE
+  });
+
+  it("converts WebKit expires_utc to epoch ms", () => {
+    // 2026-05-25 00:00:00 UTC = 1779999600000 ms epoch
+    //   = 13422518400000000 µs WebKit (epoch + 11644473600 * 1e6)
+    const expiresMs = 1779999600000;
+    const expiresWk = (BigInt(expiresMs) * 1000n + 11_644_473_600_000_000n).toString();
+    buildCookiesFixture([
+      {
+        hostKey: ".bilibili.com",
+        name: "SESSDATA",
+        value: "x",
+        expiresUtc: expiresWk,
+      },
+    ]);
+    const out = readChromiumCookies(dbPath, "bilibili.com");
+    expect(out[0].expiresMs).toBe(expiresMs);
+  });
+
+  it("throws clear error when cookies table missing (not a Cookies DB)", () => {
+    const db = new Database(dbPath);
+    db.exec("CREATE TABLE not_cookies(x INTEGER);");
+    db.close();
+    // PRAGMA table_info(<nonexistent>) returns empty rather than throwing
+    // on SQLite, so we hit the "empty / unreadable" branch. Either message
+    // is fine for the caller's purpose — both mean "not a Cookies DB".
+    expect(() => readChromiumCookies(dbPath, "bilibili.com")).toThrow(
+      /cookies.*(table not found|table empty.*unreadable)/,
+    );
+  });
+
+  it("throws clear error when required column missing", () => {
+    const db = new Database(dbPath);
+    db.exec("CREATE TABLE cookies(creation_utc INTEGER, host_key TEXT);");
+    db.close();
+    expect(() => readChromiumCookies(dbPath, "bilibili.com")).toThrow(
+      /required column.*missing/,
+    );
+  });
+
+  it("rejects empty dbPath", () => {
+    expect(() => readChromiumCookies("", "bilibili.com")).toThrow(TypeError);
+  });
+
+  it("rejects empty domain", () => {
+    buildCookiesFixture([{ hostKey: ".bilibili.com", name: "SESSDATA", value: "x" }]);
+    expect(() => readChromiumCookies(dbPath, "")).toThrow(TypeError);
+  });
+});
+
+// ─── assembleBilibiliCookieHeader ───────────────────────────────────────
+
+describe("assembleBilibiliCookieHeader", () => {
+  function cookieRow(name, value, hostKey = ".bilibili.com") {
+    return {
+      name,
+      value,
+      hostKey,
+      expiresMs: null,
+      isSecure: false,
+      isHttponly: true,
+      isPersistent: true,
+      hasEncryptedValue: false,
+    };
+  }
+
+  it("assembles complete header when all 5 cookies present", () => {
+    const cookies = [
+      cookieRow("SESSDATA", "abc"),
+      cookieRow("bili_jct", "csrf"),
+      cookieRow("DedeUserID", "1234"),
+      cookieRow("DedeUserID__ckMd5", "deadbeef"),
+      cookieRow("buvid3", "buvid-x"),
+    ];
+    const { header, missing, present } = assembleBilibiliCookieHeader(cookies);
+    expect(missing).toEqual([]);
+    expect(header).toBe(
+      "SESSDATA=abc; bili_jct=csrf; DedeUserID=1234; DedeUserID__ckMd5=deadbeef; buvid3=buvid-x",
+    );
+    expect(present).toEqual(new Set(BILIBILI_COOKIE_NAMES));
+  });
+
+  it("returns null header + missing list when any required cookie absent", () => {
+    const cookies = [
+      cookieRow("SESSDATA", "abc"),
+      cookieRow("bili_jct", "csrf"),
+      // missing DedeUserID, DedeUserID__ckMd5, buvid3
+    ];
+    const { header, missing } = assembleBilibiliCookieHeader(cookies);
+    expect(header).toBe(null);
+    expect(missing.sort()).toEqual(["DedeUserID", "DedeUserID__ckMd5", "buvid3"].sort());
+  });
+
+  it("ignores non-bilibili cookies if accidentally passed in", () => {
+    const cookies = [
+      cookieRow("SESSDATA", "abc"),
+      cookieRow("bili_jct", "csrf"),
+      cookieRow("DedeUserID", "1234"),
+      cookieRow("DedeUserID__ckMd5", "deadbeef"),
+      cookieRow("buvid3", "buvid-x"),
+      cookieRow("randomNoise", "ignored", ".weibo.com"),
+    ];
+    const { header } = assembleBilibiliCookieHeader(cookies);
+    expect(header).not.toContain("randomNoise");
+    expect(header).not.toContain("ignored");
+  });
+
+  it("prefers more-specific host_key on duplicate names", () => {
+    const cookies = [
+      cookieRow("SESSDATA", "shorter", ".bilibili.com"),
+      cookieRow("SESSDATA", "longer", "api.bilibili.com"), // longer host wins
+      cookieRow("bili_jct", "csrf"),
+      cookieRow("DedeUserID", "1234"),
+      cookieRow("DedeUserID__ckMd5", "deadbeef"),
+      cookieRow("buvid3", "buvid-x"),
+    ];
+    const { header } = assembleBilibiliCookieHeader(cookies);
+    expect(header).toContain("SESSDATA=longer");
+    expect(header).not.toContain("SESSDATA=shorter");
+  });
+
+  it("throws TypeError when given non-array", () => {
+    expect(() => assembleBilibiliCookieHeader(null)).toThrow(TypeError);
+    expect(() => assembleBilibiliCookieHeader({})).toThrow(TypeError);
+  });
+
+  it("returns null header for empty cookie list (all 5 missing)", () => {
+    const { header, missing } = assembleBilibiliCookieHeader([]);
+    expect(header).toBe(null);
+    expect(missing.length).toBe(BILIBILI_COOKIE_NAMES.length);
+  });
+});
+
+// ─── BILIBILI_COOKIE_NAMES contract ─────────────────────────────────────
+
+describe("BILIBILI_COOKIE_NAMES", () => {
+  it("is frozen", () => {
+    expect(Object.isFrozen(BILIBILI_COOKIE_NAMES)).toBe(true);
+  });
+
+  it("contains the 5 expected names", () => {
+    expect(BILIBILI_COOKIE_NAMES).toEqual([
+      "SESSDATA",
+      "bili_jct",
+      "DedeUserID",
+      "DedeUserID__ckMd5",
+      "buvid3",
+    ]);
+  });
+});

package/__tests__/adapters/social-bilibili-adb-collector.test.js

@@ -0,0 +1,284 @@
+"use strict";
+
+/**
+ * Phase 1b — unit cover for the BilibiliAdbCollector orchestrator.
+ *
+ * Strategy: mock bridge + ApiClient + registry as plain objects so we
+ * verify the orchestration logic (call order, error propagation,
+ * partial-result tolerance, cleanup) without spawning real ADB or
+ * hitting api.bilibili.com.
+ *
+ * What we cover:
+ *  - collect() — bridge.invoke → 4 fetches → snapshot file written
+ *  - collect() returns counts + diagnostic
+ *  - collect() rejects malformed bridge payload
+ *  - collect() propagates bridge.invoke errors
+ *  - collect() tolerates any-of-4 endpoint failure (partial)
+ *  - collect() tolerates ALL 4 endpoints empty (0-event snapshot)
+ *  - collectAndSync() — pipes snapshot to registry + always cleans up
+ *  - collectAndSync() cleanup happens even on syncAdapter throw
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { existsSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const {
+  collect,
+  collectAndSync,
+} = require("../../lib/adapters/social-bilibili-adb/collector");
+
+let stagingDir;
+
+beforeEach(() => {
+  stagingDir = mkdtempSync(join(tmpdir(), "cc-collector-test-"));
+});
+
+afterEach(() => {
+  try {
+    rmSync(stagingDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+function makeFakeBridge(invokeResult) {
+  return {
+    invoke: vi.fn(async () => {
+      if (invokeResult instanceof Error) throw invokeResult;
+      return invokeResult;
+    }),
+  };
+}
+
+function makeFakeApiClient({
+  history = [],
+  favourites = [],
+  dynamics = [],
+  follows = [],
+  lastErrorCode = 0,
+  lastErrorMessage = null,
+} = {}) {
+  return {
+    fetchHistory: vi.fn(async () => history),
+    fetchFavourites: vi.fn(async () => favourites),
+    fetchDynamics: vi.fn(async () => dynamics),
+    fetchFollows: vi.fn(async () => follows),
+    lastErrorCode,
+    lastErrorMessage,
+  };
+}
+
+// ─── collect() ──────────────────────────────────────────────────────────
+
+describe("collect — happy path", () => {
+  it("invokes bridge, fetches 4 endpoints, writes snapshot, returns counts", async () => {
+    const bridge = makeFakeBridge({
+      cookie: "SESSDATA=x; DedeUserID=1234567890; ...",
+      uid: 1234567890,
+      diagnostic: { cookieCount: 5 },
+    });
+    const apiClient = makeFakeApiClient({
+      history: [{ bvid: "BV1", title: "h", viewAt: 1 }],
+      favourites: [{ bvid: "BVf", title: "f", savedAt: 2 }],
+      dynamics: [{ rid: "r1", summary: "d", dynamicType: "av", publishedAt: 3 }],
+      follows: [{ mid: 1, uname: "u", followedAt: 4 }],
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+
+    expect(bridge.invoke).toHaveBeenCalledWith("bilibili.cookies");
+    expect(apiClient.fetchHistory).toHaveBeenCalled();
+    expect(apiClient.fetchFavourites).toHaveBeenCalledWith(
+      "SESSDATA=x; DedeUserID=1234567890; ...",
+      1234567890,
+      expect.any(Object),
+    );
+    expect(apiClient.fetchDynamics).toHaveBeenCalled();
+    expect(apiClient.fetchFollows).toHaveBeenCalled();
+
+    expect(result.uid).toBe(1234567890);
+    expect(result.eventCounts).toEqual({
+      history: 1,
+      favourite: 1,
+      dynamic: 1,
+      follow: 1,
+      total: 4,
+    });
+    expect(existsSync(result.snapshotPath)).toBe(true);
+    const snap = JSON.parse(readFileSync(result.snapshotPath, "utf-8"));
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.events).toHaveLength(4);
+    expect(result.cookieDiagnostic).toEqual({ cookieCount: 5 });
+  });
+
+  it("forwards lastErrorCode + lastErrorMessage from api client", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 1 });
+    const apiClient = makeFakeApiClient({
+      lastErrorCode: -412,
+      lastErrorMessage: "anti-spider",
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.lastErrorCode).toBe(-412);
+    expect(result.lastErrorMessage).toBe("anti-spider");
+  });
+
+  it("calls 4 endpoints in parallel (Promise.all)", async () => {
+    const order = [];
+    const apiClient = {
+      fetchHistory: async () => {
+        order.push("history-start");
+        await new Promise((r) => setTimeout(r, 10));
+        order.push("history-end");
+        return [];
+      },
+      fetchFavourites: async () => {
+        order.push("favourites-start");
+        await new Promise((r) => setTimeout(r, 10));
+        order.push("favourites-end");
+        return [];
+      },
+      fetchDynamics: async () => {
+        order.push("dynamics-start");
+        await new Promise((r) => setTimeout(r, 10));
+        order.push("dynamics-end");
+        return [];
+      },
+      fetchFollows: async () => {
+        order.push("follows-start");
+        await new Promise((r) => setTimeout(r, 10));
+        order.push("follows-end");
+        return [];
+      },
+      lastErrorCode: 0,
+      lastErrorMessage: null,
+    };
+    const bridge = makeFakeBridge({ cookie: "x", uid: 1 });
+    await collect(bridge, { apiClient, stagingDir });
+    // All 4 "start" events should fire before any "end" event (parallel)
+    const firstEnd = order.findIndex((e) => e.endsWith("-end"));
+    const startsBeforeFirstEnd = order.slice(0, firstEnd).filter((e) => e.endsWith("-start"));
+    expect(startsBeforeFirstEnd).toHaveLength(4);
+  });
+});
+
+describe("collect — failure modes", () => {
+  it("propagates bridge.invoke error", async () => {
+    const bridge = makeFakeBridge(new Error("BILIBILI_NO_ROOT: ..."));
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(
+      /BILIBILI_NO_ROOT/,
+    );
+  });
+
+  it("throws TypeError when bridge missing invoke fn", async () => {
+    await expect(collect(null, { stagingDir })).rejects.toThrow(TypeError);
+    await expect(collect({}, { stagingDir })).rejects.toThrow(TypeError);
+  });
+
+  it("throws when bridge returns malformed payload", async () => {
+    const bridge = makeFakeBridge({ cookie: null, uid: null });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(
+      /malformed payload/,
+    );
+  });
+
+  it("throws when uid is not positive", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 0 });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow();
+  });
+});
+
+describe("collect — partial result tolerance", () => {
+  it("succeeds with 0 events when ALL 4 endpoints empty", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 1 });
+    const apiClient = makeFakeApiClient(); // all empty
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.eventCounts.total).toBe(0);
+    expect(existsSync(result.snapshotPath)).toBe(true);
+  });
+
+  it("succeeds with partial event set when one endpoint fails (returns [])", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 1 });
+    const apiClient = makeFakeApiClient({
+      history: [{ bvid: "BV1", title: "h", viewAt: 1 }],
+      favourites: [], // simulated failure
+      dynamics: [],
+      follows: [{ mid: 1, uname: "u", followedAt: 1 }],
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.eventCounts).toEqual({
+      history: 1,
+      favourite: 0,
+      dynamic: 0,
+      follow: 1,
+      total: 2,
+    });
+  });
+});
+
+// ─── collectAndSync() ───────────────────────────────────────────────────
+
+describe("collectAndSync — pipes to registry + cleans up", () => {
+  it("calls registry.syncAdapter with snapshot path + returns merged report", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 42 });
+    const apiClient = makeFakeApiClient({
+      history: [{ bvid: "BV1", title: "h", viewAt: 1 }],
+    });
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (name, opts) => {
+        if (name !== "social-bilibili") throw new Error("wrong name");
+        syncedPath = opts.inputPath;
+        return {
+          adapter: name,
+          status: "ok",
+          rawCount: 1,
+          entityCounts: { events: 1, persons: 0, places: 0, items: 0, topics: 0 },
+        };
+      }),
+    };
+
+    const report = await collectAndSync(bridge, registry, {
+      apiClient,
+      stagingDir,
+    });
+
+    expect(registry.syncAdapter).toHaveBeenCalledWith("social-bilibili", {
+      inputPath: expect.any(String),
+    });
+    expect(syncedPath).toBeTruthy();
+    expect(report.status).toBe("ok");
+    expect(report.rawCount).toBe(1);
+    expect(report.bilibili.uid).toBe(42);
+    expect(report.bilibili.eventCounts.history).toBe(1);
+    // Cleanup happened: the snapshot file should be gone
+    expect(existsSync(syncedPath)).toBe(false);
+  });
+
+  it("cleans up snapshot file even when syncAdapter throws", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 42 });
+    const apiClient = makeFakeApiClient();
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (_name, opts) => {
+        syncedPath = opts.inputPath;
+        throw new Error("simulated registry failure");
+      }),
+    };
+    await expect(
+      collectAndSync(bridge, registry, { apiClient, stagingDir }),
+    ).rejects.toThrow("simulated registry failure");
+    expect(syncedPath).toBeTruthy();
+    expect(existsSync(syncedPath)).toBe(false); // cleanup ran
+  });
+
+  it("throws TypeError when registry missing syncAdapter fn", async () => {
+    const bridge = makeFakeBridge({ cookie: "x", uid: 1 });
+    await expect(
+      collectAndSync(bridge, null, { apiClient: makeFakeApiClient() }),
+    ).rejects.toThrow(TypeError);
+    await expect(
+      collectAndSync(bridge, {}, { apiClient: makeFakeApiClient() }),
+    ).rejects.toThrow(TypeError);
+  });
+});