@chainlesschain/personal-data-hub 0.4.28 → 0.4.30

package/__tests__/sidecar-supervisor.test.js

@@ -1,128 +0,0 @@
-"use strict";
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import path from "node:path";
-import fs from "node:fs";
-
-const {
-  SidecarSupervisor,
-  SidecarTimeoutError,
-  SidecarMethodError,
-  SidecarNotRunningError,
-} = require("../lib/sidecar");
-
-const SIDECAR_ROOT = path.resolve(
-  __dirname,
-  "..",
-  "..",
-  "personal-data-hub-bridge",
-);
-
-/**
- * Spawn the forensics-bridge sidecar from this repo's sibling package.
- * Tests are skipped if Python is unavailable on PATH (CI matrix coverage
- * is the source of truth; local dev without Python should not be blocked).
- */
-function makeSupervisor() {
-  return new SidecarSupervisor({
-    command: process.env.FORENSICS_BRIDGE_PYTHON || "python",
-    args: ["-u", "-m", "forensics_bridge.ipc_server"],
-    cwd: SIDECAR_ROOT,
-    healthCheckIntervalMs: 0, // disable for tests — manual control only
-    env: { PYTHONPATH: SIDECAR_ROOT },
-  });
-}
-
-let pythonAvailable = true;
-try {
-  // Cheap synchronous probe — spawn fails if python is not on PATH.
-  const { spawnSync } = require("node:child_process");
-  const probe = spawnSync(
-    process.env.FORENSICS_BRIDGE_PYTHON || "python",
-    ["--version"],
-    { stdio: "ignore" },
-  );
-  if (probe.status !== 0) pythonAvailable = false;
-} catch (_err) {
-  pythonAvailable = false;
-}
-
-// In the FTS5 sandbox runner the relative ../../personal-data-hub-bridge
-// resolves outside the temp tree and the directory does not exist; without
-// this gate, spawn() returns ENOENT and the test fails for environment
-// reasons rather than code reasons. Keep both gates so the file is safe
-// to run in either layout.
-const sidecarRootAvailable = fs.existsSync(SIDECAR_ROOT);
-
-const itPy = pythonAvailable && sidecarRootAvailable ? it : it.skip;
-
-describe("SidecarSupervisor (forensics-bridge integration)", () => {
-  let supervisor;
-
-  beforeEach(() => {
-    supervisor = makeSupervisor();
-  });
-
-  afterEach(async () => {
-    if (supervisor) await supervisor.stop({ graceMs: 1500 });
-  });
-
-  itPy("starts the sidecar and round-trips sidecar.ping", async () => {
-    await supervisor.start({ readyTimeoutMs: 8_000 });
-    expect(supervisor.isRunning()).toBe(true);
-
-    const ping = await supervisor.invoke("sidecar.ping", {}, { timeoutMs: 3_000 });
-    expect(ping.version).toMatch(/^\d+\.\d+\.\d+/);
-    expect(ping.pythonVersion).toMatch(/^3\./);
-  });
-
-  itPy("sidecar.capabilities exposes registered methods", async () => {
-    await supervisor.start({ readyTimeoutMs: 8_000 });
-
-    const caps = await supervisor.invoke("sidecar.capabilities");
-    expect(caps.methods).toContain("sidecar.ping");
-    expect(caps.methods).toContain("sidecar.capabilities");
-    // Namespace registry grows as parsers/extractors land; Phase 4.5.2 brings
-    // the system parser online.
-    expect(caps.parsers).toContain("system");
-    expect(caps.extractors).toContain("android");
-  });
-
-  itPy("METHOD_NOT_FOUND surfaces as a typed SidecarMethodError", async () => {
-    await supervisor.start({ readyTimeoutMs: 8_000 });
-
-    await expect(
-      supervisor.invoke("definitely.not.a.real.method"),
-    ).rejects.toMatchObject({
-      name: "SidecarMethodError",
-      code: "METHOD_NOT_FOUND",
-      retryable: false,
-    });
-  });
-
-  itPy("invoke rejects with SidecarNotRunningError when sidecar is stopped", async () => {
-    await supervisor.start({ readyTimeoutMs: 8_000 });
-    await supervisor.stop({ graceMs: 1500 });
-    expect(supervisor.isRunning()).toBe(false);
-
-    await expect(supervisor.invoke("sidecar.ping")).rejects.toMatchObject({
-      name: "SidecarNotRunningError",
-      code: "SIDECAR_NOT_RUNNING",
-    });
-  });
-
-  itPy("two sequential invokes share one sidecar process", async () => {
-    await supervisor.start({ readyTimeoutMs: 8_000 });
-    const first = await supervisor.invoke("sidecar.ping");
-    const second = await supervisor.invoke("sidecar.capabilities");
-    expect(first.version).toBeDefined();
-    expect(second.methods).toContain("sidecar.ping");
-  });
-
-  itPy("error class hierarchy is exported", () => {
-    expect(typeof SidecarSupervisor).toBe("function");
-    expect(typeof SidecarTimeoutError).toBe("function");
-    expect(typeof SidecarMethodError).toBe("function");
-    expect(typeof SidecarNotRunningError).toBe("function");
-  });
-});

package/__tests__/sign-providers.test.js

@@ -1,62 +0,0 @@
-"use strict";
-
-/**
- * Phase 6a — SignProvider abstract + NullSignProvider unit cover.
- */
-
-import { describe, it, expect } from "vitest";
-
-const {
-  SignProvider,
-  NullSignProvider,
-  NULL_SIGN_PROVIDER,
-} = require("../lib/sign-providers");
-
-describe("SignProvider abstract base", () => {
-  it("signUrl returns null by default", async () => {
-    const p = new SignProvider();
-    expect(await p.signUrl("https://example.com", "purpose")).toBe(null);
-  });
-
-  it("signedHeaders returns {} by default", async () => {
-    const p = new SignProvider();
-    const r = await p.signedHeaders("https://example.com", "purpose");
-    expect(r).toEqual({});
-  });
-
-  it("shutdown is no-op (no throw)", async () => {
-    const p = new SignProvider();
-    await expect(p.shutdown()).resolves.toBeUndefined();
-  });
-});
-
-describe("NullSignProvider", () => {
-  it("extends SignProvider", () => {
-    const p = new NullSignProvider();
-    expect(p).toBeInstanceOf(SignProvider);
-  });
-
-  it("inherits stub signUrl / signedHeaders / shutdown", async () => {
-    const p = new NullSignProvider();
-    expect(await p.signUrl("x", "y")).toBe(null);
-    expect(await p.signedHeaders("x", "y")).toEqual({});
-    await expect(p.shutdown()).resolves.toBeUndefined();
-  });
-
-  it("NULL_SIGN_PROVIDER is a frozen singleton", () => {
-    expect(NULL_SIGN_PROVIDER).toBeInstanceOf(NullSignProvider);
-    expect(Object.isFrozen(NULL_SIGN_PROVIDER)).toBe(true);
-  });
-
-  it("api-client pattern: call signUrl + signedHeaders without crash", async () => {
-    // Simulates api-client usage — signProvider.signUrl(url, purpose) ||
-    // fall back to unsigned URL; spread signedHeaders into request headers.
-    const provider = NULL_SIGN_PROVIDER;
-    const url = "https://api.example.com/x";
-    const signedUrl = (await provider.signUrl(url, "test")) || url;
-    expect(signedUrl).toBe(url); // null → fall back to original
-    const extraHeaders = await provider.signedHeaders(url, "test");
-    const finalHeaders = { Cookie: "x=y", ...extraHeaders };
-    expect(finalHeaders).toEqual({ Cookie: "x=y" }); // no extras from null provider
-  });
-});

package/__tests__/social-adapters.test.js

@@ -1,280 +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 { BilibiliAdapter, WeiboAdapter } = require("../lib");
-const { assertAdapter } = require("../lib/adapter-spec");
-const { validateBatch } = require("../lib/batch");
-
-function makeMockDriver(scriptedRows) {
-  return function () {
-    return {
-      prepare(sql) {
-        return {
-          all() {
-            for (const [matchSubstr, rows] of scriptedRows) {
-              if (sql.includes(matchSubstr)) return rows;
-            }
-            throw new Error("no such table");
-          },
-        };
-      },
-      close() {},
-    };
-  };
-}
-
-// ─── BilibiliAdapter ────────────────────────────────────────────────────
-
-describe("BilibiliAdapter", () => {
-  it("contract conformance", () => {
-    const a = new BilibiliAdapter({ account: { uid: "1234" } });
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.extractMode).toBe("device-pull");
-  });
-
-  it("accepts stateless construction (snapshot mode added in A8)", () => {
-    // Before A8: constructor required opts.account.uid. After A8 the adapter
-    // is stateless when running snapshot mode (in-APK Android cc reads a JSON
-    // produced by the phone). Sqlite mode still needs account.uid but the
-    // check moved into _syncViaSqlite where it actually matters.
-    expect(() => new BilibiliAdapter({})).not.toThrow();
-    expect(() => new BilibiliAdapter({ account: {} })).not.toThrow();
-    expect(() => new BilibiliAdapter()).not.toThrow();
-  });
-
-  it("sqlite mode rejects missing account.uid at sync time", async () => {
-    const a = new BilibiliAdapter({ dbPath: "/tmp/bili.db" });
-    // Path-existence check happens before account.uid validation, so we
-    // exercise the guard via dbPath=null + account=null which falls to
-    // "sync needs inputPath OR dbPath" first. Use a real-looking dbPath
-    // with no account to surface the account.uid throw deterministically.
-    const fs = require("node:fs");
-    const path = require("node:path");
-    const os = require("node:os");
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-no-acct-"));
-    const dbPath = path.join(dir, "bili.db");
-    fs.writeFileSync(dbPath, "fake");
-    try {
-      const b = new BilibiliAdapter({
-        dbPath,
-        dbDriverFactory: () => () => ({
-          prepare: () => ({ all: () => [] }),
-          close() {},
-        }),
-      });
-      let threw = null;
-      try {
-        for await (const _r of b.sync()) { /* drain */ }
-      } catch (err) {
-        threw = err;
-      }
-      expect(threw).toBeTruthy();
-      expect(String(threw.message)).toMatch(/account\.uid/);
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("sync yields history + favourite records via mocked driver", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-"));
-    const dbPath = path.join(dir, "bili.db");
-    fs.writeFileSync(dbPath, "fake");
-    try {
-      const mockDriver = makeMockDriver([
-        ["FROM history", [
-          { id: 1, bvid: "BV1abc", title: "趣味视频", view_at: 1700000000, uploader: "UpA" },
-          { id: 2, bvid: "BV1xyz", title: "教程", view_at: 1700000010, uploader: "UpB", duration: 300 },
-        ]],
-        ["FROM bili_favourite", [
-          { id: 1, bvid: "BV1fav", title: "收藏A", save_time: 1700001000, folder_name: "学习" },
-        ]],
-      ]);
-      const a = new BilibiliAdapter({
-        account: { uid: "1234" },
-        dbPath,
-        dbDriverFactory: () => mockDriver,
-      });
-      const raws = [];
-      for await (const r of a.sync()) raws.push(r);
-      expect(raws.length).toBe(3); // 2 history + 1 favourite
-      const histories = raws.filter((r) => r.payload.kind === "history");
-      const favs = raws.filter((r) => r.payload.kind === "favourite");
-      expect(histories).toHaveLength(2);
-      expect(favs).toHaveLength(1);
-
-      // Normalize each
-      for (const raw of raws) {
-        const batch = a.normalize(raw);
-        const v = validateBatch(batch);
-        expect(v.valid).toBe(true);
-        const subtype = batch.events[0].subtype;
-        if (raw.payload.kind === "history") expect(subtype).toBe("browse");
-        if (raw.payload.kind === "favourite") expect(subtype).toBe("like");
-      }
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("throws when neither inputPath nor dbPath provided (A8: surface config errors)", async () => {
-    // Before A8: sync silently yielded 0 if dbPath missing — masked typos and
-    // misconfigured callers. After A8 we throw so callers see the problem.
-    const a = new BilibiliAdapter({ account: { uid: "1234" } });
-    let threw = null;
-    try {
-      for await (const _r of a.sync()) { /* drain */ }
-    } catch (err) {
-      threw = err;
-    }
-    expect(threw).toBeTruthy();
-    expect(String(threw.message)).toMatch(/inputPath|dbPath/);
-  });
-
-  it("normalize captures bvid/avid/uploader into extra (flat payload, A8 shape)", async () => {
-    const a = new BilibiliAdapter({ account: { uid: "1234" } });
-    const raw = {
-      adapter: "social-bilibili",
-      kind: "history",
-      originalId: "bilibili:history:BV1abc",
-      capturedAt: 1700000000000,
-      payload: {
-        kind: "history",
-        title: "Test",
-        bvid: "BV1abc",
-        avid: "1234",
-        uploader: "UpA",
-        duration: 300,
-      },
-    };
-    const batch = a.normalize(raw);
-    expect(batch.events[0].extra.bvid).toBe("BV1abc");
-    expect(batch.events[0].extra.avid).toBe("1234");
-    expect(batch.events[0].extra.uploader).toBe("UpA");
-    expect(batch.events[0].extra.duration).toBe(300);
-    // A8: history also yields an item entity (video) for KG linkage
-    expect(batch.items).toHaveLength(1);
-    expect(batch.items[0].extra.bvid).toBe("BV1abc");
-  });
-});
-
-// ─── WeiboAdapter ───────────────────────────────────────────────────────
-
-describe("WeiboAdapter", () => {
-  it("contract conformance", () => {
-    const a = new WeiboAdapter({ account: { uid: "1234" } });
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.extractMode).toBe("device-pull");
-    expect(a.capabilities).toContain("sync:snapshot");
-    expect(a.capabilities).toContain("sync:sqlite");
-  });
-
-  it("snapshot mode constructs without account.uid (stateless)", () => {
-    // §A8 v0.2: constructor loosened — snapshot mode pulls account from the
-    // snapshot file. Sqlite mode still requires account.uid, checked at sync
-    // time not construction.
-    const a = new WeiboAdapter({});
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.account).toBeNull();
-  });
-
-  it("sqlite mode throws at sync time when account.uid missing", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "weibo-"));
-    const dbPath = path.join(dir, "weibo.db");
-    fs.writeFileSync(dbPath, "fake");
-    try {
-      const a = new WeiboAdapter({});
-      let threw = null;
-      try {
-        for await (const _r of a.sync({ dbPath })) { /* drain */ }
-      } catch (e) {
-        threw = e;
-      }
-      expect(threw).not.toBeNull();
-      expect(threw.message).toMatch(/account\.uid/);
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("sync yields posts + search records via mocked driver", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "weibo-"));
-    const dbPath = path.join(dir, "weibo.db");
-    fs.writeFileSync(dbPath, "fake");
-    try {
-      const mockDriver = makeMockDriver([
-        ["FROM post", [
-          { id: 1, mid: "M1", text: "今天天气真好", created_at: 1700000000, reposts_count: 5, comments_count: 3 },
-        ]],
-        ["FROM status", []],
-        ["FROM search_history", [
-          { id: 1, keyword: "iPhone", time: 1700001000 },
-          { id: 2, keyword: "音乐", time: 1700001100 },
-        ]],
-      ]);
-      const a = new WeiboAdapter({
-        account: { uid: "1234" },
-        dbPath,
-        dbDriverFactory: () => mockDriver,
-      });
-      const raws = [];
-      for await (const r of a.sync()) raws.push(r);
-      expect(raws.length).toBe(3); // 1 post + 2 searches
-
-      for (const raw of raws) {
-        const batch = a.normalize(raw);
-        const v = validateBatch(batch);
-        expect(v.valid).toBe(true);
-        const subtype = batch.events[0].subtype;
-        if (raw.payload.kind === "post") expect(subtype).toBe("post");
-        if (raw.payload.kind === "search") expect(subtype).toBe("interaction");
-      }
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("normalize captures post metrics", async () => {
-    const a = new WeiboAdapter({ account: { uid: "1234" } });
-    const raw = {
-      adapter: "social-weibo",
-      originalId: "post-M1",
-      capturedAt: 1700000000000,
-      payload: {
-        kind: "post",
-        row: {
-          id: 1, mid: "M1", text: "测试",
-          created_at: 1700000000,
-          reposts_count: 5, comments_count: 3, attitudes_count: 10,
-          location: "上海",
-        },
-      },
-    };
-    const batch = a.normalize(raw);
-    expect(batch.events[0].extra.weiboMid).toBe("M1");
-    expect(batch.events[0].extra.repostsCount).toBe(5);
-    expect(batch.events[0].extra.commentsCount).toBe(3);
-    expect(batch.events[0].extra.likesCount).toBe(10);
-    expect(batch.events[0].extra.location).toBe("上海");
-  });
-
-  it("normalize falls back when text is empty", async () => {
-    const a = new WeiboAdapter({ account: { uid: "1234" } });
-    const raw = {
-      adapter: "social-weibo",
-      originalId: "post-x",
-      capturedAt: Date.now(),
-      payload: {
-        kind: "post",
-        row: { id: 1, mid: "X", text: "", created_at: Math.floor(Date.now() / 1000) },
-      },
-    };
-    const batch = a.normalize(raw);
-    expect(batch.events[0].content.title).toBe("(空)");
-    expect(validateBatch(batch).valid).toBe(true);
-  });
-});