@chainlesschain/personal-data-hub 0.3.1 → 0.3.6

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

@@ -0,0 +1,254 @@
+"use strict";
+
+/**
+ * Phase 2a — Douyin C 路径 collector orchestrator unit cover.
+ *
+ * Same fake-bridge + fake-registry pattern as social-bilibili-adb-collector.
+ */
+
+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";
+import Database from "better-sqlite3";
+
+const {
+  collect,
+  collectAndSync,
+} = require("../../lib/adapters/social-douyin-adb/collector");
+
+let stagingDir;
+let dbDir;
+let fixtureDbPath;
+
+beforeEach(() => {
+  stagingDir = mkdtempSync(join(tmpdir(), "cc-douyin-staging-"));
+  dbDir = mkdtempSync(join(tmpdir(), "cc-douyin-dbfixture-"));
+  fixtureDbPath = join(dbDir, "fixture-1234567890123456789_im.db");
+  // Build a small valid IM db so the collector has real data to parse.
+  const db = new Database(fixtureDbPath);
+  db.exec(`
+    CREATE TABLE msg(
+      sender INTEGER, created_time INTEGER, content TEXT,
+      conversation_id TEXT, read_status INTEGER
+    );
+    CREATE TABLE SIMPLE_USER(
+      UID INTEGER, short_id INTEGER, name TEXT,
+      avatar_url TEXT, follow_status INTEGER
+    );
+    INSERT INTO msg VALUES(123, 1716383021000, '{"text":"hi"}', 'conv-A', 1);
+    INSERT INTO msg VALUES(456, 1716383022000, '{"text":"hi back"}', 'conv-A', 0);
+    INSERT INTO SIMPLE_USER VALUES(456, 789, 'Friend', 'https://x', 1);
+  `);
+  db.close();
+});
+
+afterEach(() => {
+  try {
+    rmSync(stagingDir, { recursive: true, force: true });
+    rmSync(dbDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+function makeFakeBridge({ pullResult, throwOnInvoke } = {}) {
+  return {
+    invoke: vi.fn(async (method, _params) => {
+      if (throwOnInvoke) throw throwOnInvoke;
+      if (method !== "douyin.pull-im-db") {
+        throw new Error(`fake bridge: unexpected method ${method}`);
+      }
+      return pullResult;
+    }),
+  };
+}
+
+function makeCleanupSpy() {
+  return vi.fn();
+}
+
+// ─── collect() — happy path ─────────────────────────────────────────────
+
+describe("collect — happy path", () => {
+  it("invokes bridge, parses db, writes snapshot, returns counts", async () => {
+    const cleanup = makeCleanupSpy();
+    const bridge = makeFakeBridge({
+      pullResult: {
+        tempPath: fixtureDbPath,
+        uid: "1234567890123456789",
+        walPath: null,
+        shmPath: null,
+        extractedAt: 1716383020000,
+        cleanup,
+      },
+    });
+    const result = await collect(bridge, { stagingDir });
+    expect(bridge.invoke).toHaveBeenCalledWith("douyin.pull-im-db", {
+      uid: undefined,
+    });
+    expect(result.uid).toBe("1234567890123456789");
+    expect(result.eventCounts).toEqual({
+      message: 2,
+      contact: 1,
+      total: 3,
+    });
+    expect(existsSync(result.snapshotPath)).toBe(true);
+    const snap = JSON.parse(readFileSync(result.snapshotPath, "utf-8"));
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.events).toHaveLength(3);
+    expect(result.parserDiagnostic.hadMsgTable).toBe(true);
+    expect(result.parserDiagnostic.hadSimpleUserTable).toBe(true);
+    // collect() does NOT cleanup db cohort yet — that's caller's
+    // responsibility (collectAndSync runs cleanup after syncAdapter).
+    expect(cleanup).not.toHaveBeenCalled();
+    expect(typeof result._dbCohortCleanup).toBe("function");
+  });
+
+  it("forwards uid filter to extension", async () => {
+    const bridge = makeFakeBridge({
+      pullResult: {
+        tempPath: fixtureDbPath,
+        uid: "1234567890123456789",
+        cleanup: () => {},
+      },
+    });
+    await collect(bridge, { stagingDir, uid: "1234567890123456789" });
+    expect(bridge.invoke).toHaveBeenCalledWith("douyin.pull-im-db", {
+      uid: "1234567890123456789",
+    });
+  });
+
+  it("forwards limits to parser", async () => {
+    const bridge = makeFakeBridge({
+      pullResult: {
+        tempPath: fixtureDbPath,
+        uid: "1234567890123456789",
+        cleanup: () => {},
+      },
+    });
+    const result = await collect(bridge, {
+      stagingDir,
+      limits: { messages: 1, contacts: 0 },
+    });
+    expect(result.eventCounts.message).toBe(1);
+    // contacts: 0 → fallback to default 5000 (parser uses default when
+    // limit is 0; that's intentional per im-db-parser.js).
+    expect(result.eventCounts.contact).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ─── collect() — failure modes ──────────────────────────────────────────
+
+describe("collect — failure modes", () => {
+  it("propagates bridge.invoke errors verbatim", async () => {
+    const bridge = makeFakeBridge({
+      throwOnInvoke: new Error("DOUYIN_NO_ROOT: phone isn't rooted"),
+    });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(
+      /DOUYIN_NO_ROOT/,
+    );
+  });
+
+  it("rejects malformed bridge payload", async () => {
+    const bridge = makeFakeBridge({
+      pullResult: { uid: null, tempPath: null },
+    });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(
+      /malformed payload/,
+    );
+  });
+
+  it("rejects bridge missing invoke fn", async () => {
+    await expect(collect(null, { stagingDir })).rejects.toThrow(TypeError);
+    await expect(collect({}, { stagingDir })).rejects.toThrow(TypeError);
+  });
+
+  it("cleans up db cohort if snapshot building throws", async () => {
+    const cleanup = makeCleanupSpy();
+    const bridge = makeFakeBridge({
+      pullResult: {
+        tempPath: "/nonexistent/db/path.db", // parser will throw
+        uid: "1234567890123456789",
+        cleanup,
+      },
+    });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow();
+    expect(cleanup).toHaveBeenCalledOnce();
+  });
+});
+
+// ─── collectAndSync() ───────────────────────────────────────────────────
+
+describe("collectAndSync — pipes to registry + always cleans up", () => {
+  it("calls registry.syncAdapter('social-douyin') + merges report", async () => {
+    const cleanup = makeCleanupSpy();
+    const bridge = makeFakeBridge({
+      pullResult: {
+        tempPath: fixtureDbPath,
+        uid: "1234567890123456789",
+        cleanup,
+      },
+    });
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (name, opts) => {
+        if (name !== "social-douyin") throw new Error("wrong name");
+        syncedPath = opts.inputPath;
+        return {
+          adapter: name,
+          status: "ok",
+          rawCount: 3,
+          entityCounts: { events: 3, persons: 0, places: 0, items: 0, topics: 0 },
+        };
+      }),
+    };
+    const report = await collectAndSync(bridge, registry, { stagingDir });
+    expect(registry.syncAdapter).toHaveBeenCalledWith("social-douyin", {
+      inputPath: expect.any(String),
+    });
+    expect(syncedPath).toBeTruthy();
+    expect(report.status).toBe("ok");
+    expect(report.douyin.uid).toBe("1234567890123456789");
+    expect(report.douyin.eventCounts.total).toBe(3);
+    // Both snapshot AND db cohort cleaned up
+    expect(existsSync(syncedPath)).toBe(false);
+    expect(cleanup).toHaveBeenCalledOnce();
+  });
+
+  it("cleans up both even if syncAdapter throws", async () => {
+    const cleanup = makeCleanupSpy();
+    const bridge = makeFakeBridge({
+      pullResult: {
+        tempPath: fixtureDbPath,
+        uid: "1234567890123456789",
+        cleanup,
+      },
+    });
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (_name, opts) => {
+        syncedPath = opts.inputPath;
+        throw new Error("registry exploded");
+      }),
+    };
+    await expect(
+      collectAndSync(bridge, registry, { stagingDir }),
+    ).rejects.toThrow("registry exploded");
+    expect(syncedPath).toBeTruthy();
+    expect(existsSync(syncedPath)).toBe(false);
+    expect(cleanup).toHaveBeenCalledOnce();
+  });
+
+  it("rejects missing registry.syncAdapter", async () => {
+    const bridge = makeFakeBridge({
+      pullResult: { tempPath: fixtureDbPath, uid: "1", cleanup: () => {} },
+    });
+    await expect(collectAndSync(bridge, null, { stagingDir })).rejects.toThrow(
+      TypeError,
+    );
+    await expect(collectAndSync(bridge, {}, { stagingDir })).rejects.toThrow(
+      TypeError,
+    );
+  });
+});

package/__tests__/adapters/social-douyin-adb-im-db-parser.test.js

@@ -0,0 +1,304 @@
+"use strict";
+
+/**
+ * Phase 2a — IM db parser unit cover.
+ *
+ * Builds real Douyin-shaped sqlite fixtures via better-sqlite3 (Node ABI
+ * 127 test path, same as social-bilibili-adb-chromium-cookies-reader.test.js).
+ * Tests cover:
+ *  - msg table happy path + schema-drift column aliases
+ *  - SIMPLE_USER table happy path + missing-column tolerance
+ *  - Empty db / missing table → diagnostic.hadXxxTable=false
+ *  - Time normalization: seconds / ms / microseconds
+ *  - Content blob: JSON {text} / nested .content.text / plain string
+ *  - limitMessages / limitContacts
+ */
+
+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 {
+  parseImDb,
+  _internals,
+} = require("../../lib/adapters/social-douyin-adb/im-db-parser");
+
+let tmpDir;
+let dbPath;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "cc-douyin-im-test-"));
+  dbPath = join(tmpDir, "test_im.db");
+});
+
+afterEach(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+function buildMsgFixture(rows, columnOverrides = {}) {
+  const senderCol = columnOverrides.senderCol || "sender";
+  const timeCol = columnOverrides.timeCol || "created_time";
+  const contentCol = columnOverrides.contentCol || "content";
+  const convCol = columnOverrides.convCol || "conversation_id";
+  const readCol = columnOverrides.readCol || "read_status";
+  const db = new Database(dbPath);
+  db.exec(
+    `CREATE TABLE msg(${senderCol} INTEGER, ${timeCol} INTEGER, ${contentCol} TEXT, ${convCol} TEXT, ${readCol} INTEGER);`,
+  );
+  const insert = db.prepare(
+    `INSERT INTO msg(${senderCol}, ${timeCol}, ${contentCol}, ${convCol}, ${readCol}) VALUES(?, ?, ?, ?, ?)`,
+  );
+  for (const r of rows) {
+    insert.run(
+      r.sender || 0,
+      r.time || 0,
+      r.content || "",
+      r.convId || "",
+      r.read || 0,
+    );
+  }
+  db.close();
+}
+
+function buildSimpleUserFixture(rows) {
+  const db = new Database(dbPath, { fileMustExist: false });
+  // Open in CREATE mode if not yet
+  db.exec(`CREATE TABLE IF NOT EXISTS SIMPLE_USER(
+    UID INTEGER, short_id INTEGER, name TEXT, avatar_url TEXT, follow_status INTEGER
+  );`);
+  const insert = db.prepare(
+    "INSERT INTO SIMPLE_USER(UID, short_id, name, avatar_url, follow_status) VALUES(?, ?, ?, ?, ?)",
+  );
+  for (const r of rows) {
+    insert.run(
+      r.uid || 0,
+      r.shortId || 0,
+      r.name || "",
+      r.avatar || "",
+      r.follow || 0,
+    );
+  }
+  db.close();
+}
+
+// ─── internals ──────────────────────────────────────────────────────────
+
+describe("_internals.normalizeEpochMs", () => {
+  it("treats seconds as seconds (× 1000)", () => {
+    expect(_internals.normalizeEpochMs(1716383021)).toBe(1716383021000);
+  });
+
+  it("treats milliseconds verbatim", () => {
+    expect(_internals.normalizeEpochMs(1716383021000)).toBe(1716383021000);
+  });
+
+  it("treats microseconds (× 1000 epoch) as µs / 1000", () => {
+    expect(_internals.normalizeEpochMs(1716383021000000)).toBe(1716383021000);
+  });
+
+  it("rejects zero / negative / non-number", () => {
+    expect(_internals.normalizeEpochMs(0)).toBe(null);
+    expect(_internals.normalizeEpochMs(-1)).toBe(null);
+    expect(_internals.normalizeEpochMs(NaN)).toBe(null);
+    expect(_internals.normalizeEpochMs(null)).toBe(null);
+    expect(_internals.normalizeEpochMs("123")).toBe(null);
+  });
+});
+
+describe("_internals.extractTextFromContent", () => {
+  it("parses {text:'...'} JSON", () => {
+    expect(_internals.extractTextFromContent('{"text":"hi"}')).toBe("hi");
+  });
+
+  it("parses nested {content:{text:'...'}} JSON", () => {
+    expect(
+      _internals.extractTextFromContent('{"content":{"text":"nested"}}'),
+    ).toBe("nested");
+  });
+
+  it("returns raw string when not valid JSON", () => {
+    expect(_internals.extractTextFromContent("legacy plaintext")).toBe(
+      "legacy plaintext",
+    );
+  });
+
+  it("returns null for empty / non-string", () => {
+    expect(_internals.extractTextFromContent("")).toBe(null);
+    expect(_internals.extractTextFromContent(null)).toBe(null);
+    expect(_internals.extractTextFromContent(undefined)).toBe(null);
+  });
+
+  it("returns null when JSON parses but no text field", () => {
+    expect(_internals.extractTextFromContent('{"type":"sticker"}')).toBe(null);
+  });
+});
+
+describe("_internals.pickCol", () => {
+  it("returns first matching column", () => {
+    const cols = new Set(["created_time", "sender", "content"]);
+    expect(_internals.pickCol(cols, ["create_time", "created_time"])).toBe(
+      "created_time",
+    );
+  });
+
+  it("returns null when no candidate matches", () => {
+    const cols = new Set(["a", "b"]);
+    expect(_internals.pickCol(cols, ["c", "d"])).toBe(null);
+  });
+});
+
+// ─── msg table happy path ───────────────────────────────────────────────
+
+describe("parseImDb — msg table", () => {
+  it("parses canonical msg rows", () => {
+    buildMsgFixture([
+      {
+        sender: 9007199254740991,
+        time: 1716383021000,
+        content: '{"text":"hello"}',
+        convId: "conv-A",
+        read: 1,
+      },
+      {
+        sender: 8007199254740991,
+        time: 1716383022000,
+        content: '{"text":"hi back"}',
+        convId: "conv-A",
+        read: 0,
+      },
+    ]);
+    const result = parseImDb(dbPath);
+    expect(result.diagnostic.hadMsgTable).toBe(true);
+    expect(result.diagnostic.messageCount).toBe(2);
+    expect(result.messages).toHaveLength(2);
+    // Sorted DESC by time
+    expect(result.messages[0].text).toBe("hi back");
+    expect(result.messages[1].text).toBe("hello");
+    expect(result.messages[0].conversationId).toBe("conv-A");
+    expect(result.messages[0].readStatus).toBe(0);
+  });
+
+  it("normalizes time to ms regardless of original unit", () => {
+    buildMsgFixture([
+      { sender: 1, time: 1716383021, content: '{"text":"seconds"}' },
+    ]);
+    const result = parseImDb(dbPath);
+    expect(result.messages[0].createdTimeMs).toBe(1716383021000);
+  });
+
+  it("preserves contentBlob even when text extracts to null", () => {
+    buildMsgFixture([
+      { sender: 1, time: 1716383021000, content: '{"type":"sticker"}' },
+    ]);
+    const result = parseImDb(dbPath);
+    expect(result.messages[0].text).toBe(null);
+    expect(result.messages[0].contentBlob).toBe('{"type":"sticker"}');
+  });
+
+  it("respects limitMessages", () => {
+    const rows = Array.from({ length: 100 }, (_, i) => ({
+      sender: i,
+      time: 1716383021000 + i,
+      content: `{"text":"msg-${i}"}`,
+    }));
+    buildMsgFixture(rows);
+    const result = parseImDb(dbPath, { limitMessages: 10 });
+    expect(result.messages).toHaveLength(10);
+  });
+
+  it("handles schema-drift column names (create_time / from_user_id)", () => {
+    buildMsgFixture(
+      [
+        {
+          sender: 9007199254740991,
+          time: 1716383021,
+          content: '{"text":"hi"}',
+          convId: "c",
+        },
+      ],
+      {
+        senderCol: "from_user_id",
+        timeCol: "create_time",
+        contentCol: "message_content",
+        convCol: "conv_id",
+      },
+    );
+    const result = parseImDb(dbPath);
+    expect(result.diagnostic.hadMsgTable).toBe(true);
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0].text).toBe("hi");
+    expect(result.messages[0].conversationId).toBe("c");
+  });
+
+  it("returns empty messages array when msg table absent", () => {
+    const db = new Database(dbPath);
+    db.exec("CREATE TABLE unrelated(x INTEGER);");
+    db.close();
+    const result = parseImDb(dbPath);
+    expect(result.messages).toEqual([]);
+    expect(result.diagnostic.hadMsgTable).toBe(false);
+  });
+});
+
+// ─── SIMPLE_USER table ──────────────────────────────────────────────────
+
+describe("parseImDb — SIMPLE_USER table", () => {
+  it("parses canonical contact rows", () => {
+    buildSimpleUserFixture([
+      { uid: 111, shortId: 222, name: "Alice", avatar: "https://a.png", follow: 1 },
+      { uid: 333, shortId: 444, name: "Bob", avatar: "https://b.png", follow: 2 },
+    ]);
+    const result = parseImDb(dbPath);
+    expect(result.diagnostic.hadSimpleUserTable).toBe(true);
+    expect(result.diagnostic.contactCount).toBe(2);
+    expect(result.contacts[0].name).toBe("Alice");
+    expect(result.contacts[0].followStatus).toBe(1);
+    expect(result.contacts[1].followStatus).toBe(2);
+  });
+
+  it("returns empty when SIMPLE_USER table absent", () => {
+    const db = new Database(dbPath);
+    db.exec("CREATE TABLE msg(x INTEGER);");
+    db.close();
+    const result = parseImDb(dbPath);
+    expect(result.contacts).toEqual([]);
+    expect(result.diagnostic.hadSimpleUserTable).toBe(false);
+  });
+
+  it("respects limitContacts", () => {
+    const rows = Array.from({ length: 50 }, (_, i) => ({
+      uid: i + 1,
+      shortId: i,
+      name: `user-${i}`,
+    }));
+    buildSimpleUserFixture(rows);
+    const result = parseImDb(dbPath, { limitContacts: 7 });
+    expect(result.contacts).toHaveLength(7);
+  });
+});
+
+// ─── Combined / empty ───────────────────────────────────────────────────
+
+describe("parseImDb — combined diagnostics", () => {
+  it("handles both tables present", () => {
+    buildMsgFixture([
+      { sender: 1, time: 1716383021000, content: '{"text":"hi"}' },
+    ]);
+    buildSimpleUserFixture([{ uid: 999, name: "x" }]);
+    const result = parseImDb(dbPath);
+    expect(result.diagnostic.hadMsgTable).toBe(true);
+    expect(result.diagnostic.hadSimpleUserTable).toBe(true);
+    expect(result.messages.length + result.contacts.length).toBe(2);
+  });
+
+  it("rejects non-string / empty dbPath", () => {
+    expect(() => parseImDb("")).toThrow(TypeError);
+    expect(() => parseImDb(null)).toThrow(TypeError);
+  });
+});