@chainlesschain/personal-data-hub 0.3.1 → 0.3.6

package/__tests__/adapters/social-douyin-adb-snapshot-builder.test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+/**
+ * Phase 2a — Douyin snapshot-builder unit cover.
+ *
+ * Mirrors social-bilibili-adb-snapshot-builder.test.js but with the
+ * Douyin event shapes (kind=message / kind=contact).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-douyin-adb/snapshot-builder");
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "cc-douyin-snap-test-"));
+});
+
+afterEach(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+describe("buildSnapshot — schema contract", () => {
+  it("returns documented schema shape", () => {
+    const snap = buildSnapshot({
+      uid: "1234567890123456789",
+      displayName: "alice",
+      messages: [],
+      contacts: [],
+      snapshottedAt: 1716383021000,
+    });
+    expect(snap.schemaVersion).toBe(SNAPSHOT_SCHEMA_VERSION);
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.snapshottedAt).toBe(1716383021000);
+    expect(snap.account).toEqual({
+      secUid: null, // unknown via pure-db extraction
+      shortId: "1234567890123456789",
+      displayName: "alice",
+    });
+    expect(Array.isArray(snap.events)).toBe(true);
+  });
+
+  it("rejects non-string / empty uid", () => {
+    expect(() => buildSnapshot({ uid: 123 })).toThrow(TypeError);
+    expect(() => buildSnapshot({ uid: "" })).toThrow(TypeError);
+    expect(() => buildSnapshot({})).toThrow(TypeError);
+  });
+
+  it("defaults snapshottedAt to Date.now() when omitted", () => {
+    const before = Date.now();
+    const snap = buildSnapshot({ uid: "1" });
+    const after = Date.now();
+    expect(snap.snapshottedAt).toBeGreaterThanOrEqual(before);
+    expect(snap.snapshottedAt).toBeLessThanOrEqual(after);
+  });
+
+  it("defaults displayName to empty string", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(snap.account.displayName).toBe("");
+  });
+});
+
+describe("buildSnapshot — events", () => {
+  it("maps messages → kind=message events with composite id", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [
+        {
+          senderUid: "10001",
+          conversationId: "conv-A",
+          createdTimeMs: 1716383021000,
+          text: "hi",
+          readStatus: 1,
+          contentBlob: '{"text":"hi"}',
+        },
+      ],
+    });
+    expect(snap.events).toHaveLength(1);
+    expect(snap.events[0]).toMatchObject({
+      kind: "message",
+      id: "msg-conv-A-1716383021000",
+      capturedAt: 1716383021000,
+      senderUid: "10001",
+      conversationId: "conv-A",
+      text: "hi",
+      readStatus: 1,
+      contentBlob: '{"text":"hi"}',
+    });
+  });
+
+  it("falls back to senderUid+time when conversationId absent", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [
+        {
+          senderUid: "10001",
+          conversationId: null,
+          createdTimeMs: 1716383021000,
+          text: "hi",
+        },
+      ],
+    });
+    expect(snap.events[0].id).toBe("msg-10001-1716383021000");
+  });
+
+  it("falls back to index when both conversationId + senderUid absent", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [{ text: "stray" }],
+    });
+    expect(snap.events[0].id).toBe("msg-msg-0");
+  });
+
+  it("maps contacts → kind=contact events with uid-based id", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      contacts: [
+        { uid: "111", shortId: "222", name: "Alice", avatarUrl: "https://a.png", followStatus: 1 },
+      ],
+    });
+    expect(snap.events[0]).toMatchObject({
+      kind: "contact",
+      id: "contact-111",
+      uid: "111",
+      shortId: "222",
+      name: "Alice",
+      followStatus: 1,
+    });
+  });
+
+  it("preserves message → contact ordering", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [{ senderUid: "a", createdTimeMs: 1 }],
+      contacts: [{ uid: "b" }],
+    });
+    expect(snap.events.map((e) => e.kind)).toEqual(["message", "contact"]);
+  });
+
+  it("uses snapshottedAt fallback when message has no createdTimeMs", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      snapshottedAt: 999,
+      messages: [{ senderUid: "x", text: "no time" }],
+    });
+    expect(snap.events[0].capturedAt).toBe(999);
+  });
+
+  it("skips null / non-object items", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [null, { senderUid: "a", createdTimeMs: 1 }, "junk"],
+      contacts: [undefined, { uid: "b" }],
+    });
+    expect(snap.events).toHaveLength(2);
+  });
+
+  it("handles non-array fields gracefully", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: "not an array",
+      contacts: null,
+    });
+    expect(snap.events).toEqual([]);
+  });
+});
+
+describe("writeSnapshotJson + cleanupSnapshotJson", () => {
+  it("writes JSON to default tmpdir", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    const filePath = writeSnapshotJson(snap);
+    expect(existsSync(filePath)).toBe(true);
+    expect(filePath).toContain("cc-douyin-snapshot-");
+    expect(filePath).toMatch(/\.json$/);
+    const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    expect(parsed.schemaVersion).toBe(1);
+    cleanupSnapshotJson(filePath);
+    expect(existsSync(filePath)).toBe(false);
+  });
+
+  it("respects custom dir + fileName", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    const filePath = writeSnapshotJson(snap, {
+      dir: tmpDir,
+      fileName: "custom.json",
+    });
+    expect(filePath).toBe(join(tmpDir, "custom.json"));
+  });
+
+  it("rejects path separators in fileName", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(() => writeSnapshotJson(snap, { fileName: "../evil.json" })).toThrow(
+      /must be a basename/,
+    );
+  });
+
+  it("cleanupSnapshotJson tolerates missing / null", () => {
+    cleanupSnapshotJson(null);
+    cleanupSnapshotJson(undefined);
+    cleanupSnapshotJson(join(tmpDir, "nonexistent.json"));
+    // does not throw
+  });
+});

package/__tests__/adapters/social-weibo-adb-api-client.test.js

@@ -0,0 +1,362 @@
+"use strict";
+
+/**
+ * Phase 3a — Weibo Node API client unit cover.
+ *
+ * Same fake-fetch pattern as social-bilibili-adb-api-client.test.js.
+ * Byte-parity check against WeiboApiClient.kt (Kotlin) is in
+ * `android-app/.../WeiboApiClient*Test.kt`.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+
+const { WeiboApiClient, _internals } = require(
+  "../../lib/adapters/social-weibo-adb/api-client",
+);
+
+function makeClient(responses) {
+  const calls = [];
+  const fakeFetch = async (urlStr, opts) => {
+    calls.push({ url: urlStr, opts });
+    for (const [pattern, payload] of responses) {
+      if (urlStr.includes(pattern)) {
+        const resolved =
+          typeof payload === "function" ? await payload(urlStr, opts) : payload;
+        return {
+          ok: resolved.status == null || resolved.status === 200,
+          status: resolved.status || 200,
+          text: async () => resolved.body,
+          json: async () => JSON.parse(resolved.body),
+        };
+      }
+    }
+    throw new Error("fake fetch: no scripted response for " + urlStr);
+  };
+  return { client: new WeiboApiClient({ fetch: fakeFetch }), calls };
+}
+
+const FAKE_COOKIE = "SUB=abc; SUBP=def; _T_WM=tw1; MLOGIN=1";
+
+// ─── _internals.parseWeiboTime ──────────────────────────────────────────
+
+describe("parseWeiboTime", () => {
+  it("parses 'EEE MMM dd HH:mm:ss Z yyyy' format", () => {
+    const t = _internals.parseWeiboTime("Sun Jan 12 13:45:00 +0800 2026");
+    // Sunday 2026-01-12 13:45:00 +0800 = 2026-01-12 05:45:00 UTC
+    expect(t).toBeGreaterThan(0);
+    const d = new Date(t);
+    expect(d.getUTCFullYear()).toBe(2026);
+    expect(d.getUTCMonth()).toBe(0);
+    expect(d.getUTCDate()).toBe(12);
+    expect(d.getUTCHours()).toBe(5);
+    expect(d.getUTCMinutes()).toBe(45);
+  });
+
+  it("digits-only treated as unix-seconds (< 1e12)", () => {
+    expect(_internals.parseWeiboTime("1716383021")).toBe(1716383021000);
+  });
+
+  it("digits-only treated as ms (> 1e12)", () => {
+    expect(_internals.parseWeiboTime("1716383021000")).toBe(1716383021000);
+  });
+
+  it("returns 0 for empty / null / unparseable", () => {
+    expect(_internals.parseWeiboTime("")).toBe(0);
+    expect(_internals.parseWeiboTime(null)).toBe(0);
+    expect(_internals.parseWeiboTime(undefined)).toBe(0);
+    expect(_internals.parseWeiboTime("not a date")).toBe(0);
+  });
+});
+
+// ─── _internals.stripHtml ───────────────────────────────────────────────
+
+describe("stripHtml", () => {
+  it("strips <a> / <span> tags", () => {
+    expect(
+      _internals.stripHtml(
+        '<a href="x">hello</a> <span class="y">world</span>',
+      ),
+    ).toBe("hello world");
+  });
+
+  it("decodes &nbsp; / &amp; / &lt; / &gt; / &quot;", () => {
+    expect(_internals.stripHtml("a&nbsp;b&amp;c&lt;d&gt;e&quot;f")).toBe(
+      'a b&c<d>e"f',
+    );
+  });
+
+  it("handles Chinese + emoji", () => {
+    expect(_internals.stripHtml("<p>你好 👋</p>")).toBe("你好 👋");
+  });
+
+  it("returns empty for null / empty", () => {
+    expect(_internals.stripHtml("")).toBe("");
+    expect(_internals.stripHtml(null)).toBe("");
+  });
+});
+
+// ─── fetchUid ──────────────────────────────────────────────────────────
+
+describe("WeiboApiClient.fetchUid", () => {
+  it("returns numeric UID when login=true", async () => {
+    const { client } = makeClient([
+      [
+        "api/config",
+        { body: JSON.stringify({ ok: 1, data: { login: true, uid: "1234567890" } }) },
+      ],
+    ]);
+    const uid = await client.fetchUid(FAKE_COOKIE);
+    expect(uid).toBe(1234567890);
+  });
+
+  it("returns null when login=false", async () => {
+    const { client } = makeClient([
+      [
+        "api/config",
+        { body: JSON.stringify({ ok: 1, data: { login: false } }) },
+      ],
+    ]);
+    expect(await client.fetchUid(FAKE_COOKIE)).toBe(null);
+  });
+
+  it("returns null on non-JSON (cookie expired login redirect)", async () => {
+    const { client } = makeClient([
+      ["api/config", { body: "<html>login redirect</html>" }],
+    ]);
+    expect(await client.fetchUid(FAKE_COOKIE)).toBe(null);
+    expect(client.lastErrorCode).toBe(-4);
+  });
+
+  it("returns null on HTTP error", async () => {
+    const { client } = makeClient([
+      ["api/config", { status: 503, body: "Service Unavailable" }],
+    ]);
+    expect(await client.fetchUid(FAKE_COOKIE)).toBe(null);
+    expect(client.lastErrorCode).toBe(503);
+  });
+
+  it("sends required browser headers", async () => {
+    const { client, calls } = makeClient([
+      [
+        "api/config",
+        { body: JSON.stringify({ ok: 1, data: { login: true, uid: "1" } }) },
+      ],
+    ]);
+    await client.fetchUid(FAKE_COOKIE);
+    const h = calls[0].opts.headers;
+    expect(h["User-Agent"]).toContain("Mozilla");
+    expect(h.Referer).toBe("https://m.weibo.cn/");
+    expect(h["X-Requested-With"]).toBe("XMLHttpRequest");
+    expect(h["MWeibo-Pwa"]).toBe("1");
+    expect(h.Cookie).toBe(FAKE_COOKIE);
+  });
+});
+
+// ─── fetchPosts ────────────────────────────────────────────────────────
+
+describe("WeiboApiClient.fetchPosts", () => {
+  it("parses card_type=9 mblog cards", async () => {
+    const { client } = makeClient([
+      [
+        "api/container/getIndex",
+        {
+          body: JSON.stringify({
+            ok: 1,
+            data: {
+              cards: [
+                {
+                  card_type: 9,
+                  mblog: {
+                    mid: "MBLOG_001",
+                    text: '<a href="/user/x">@friend</a> hello 你好',
+                    created_at: "Sun Jan 12 13:45:00 +0800 2026",
+                    source: '<a href="x">iPhone 16</a>',
+                    reposts_count: 5,
+                    comments_count: 10,
+                    attitudes_count: 100,
+                    pic_num: 2,
+                  },
+                },
+                { card_type: 11 /* banner — should skip */ },
+                {
+                  card_type: 9,
+                  mblog: {
+                    id: 12345, // alt id field
+                    text: "second post",
+                    created_at: "1716383021",
+                  },
+                },
+              ],
+            },
+          }),
+        },
+      ],
+    ]);
+    const posts = await client.fetchPosts(FAKE_COOKIE, 1234567890);
+    expect(posts).toHaveLength(2);
+    expect(posts[0]).toMatchObject({
+      mid: "MBLOG_001",
+      text: "@friend hello 你好",
+      // source field preserves raw HTML (Kotlin byte-parity — WeiboApiClient.kt
+      // doesn't strip it; UI can strip if it wants)
+      source: '<a href="x">iPhone 16</a>',
+      repostsCount: 5,
+      commentsCount: 10,
+      likesCount: 100,
+      picCount: 2,
+    });
+    expect(posts[1].mid).toBe("12345");
+    expect(posts[1].text).toBe("second post");
+  });
+
+  it("respects limit", async () => {
+    const items = Array.from({ length: 100 }, (_, i) => ({
+      card_type: 9,
+      mblog: { mid: `M${i}`, text: `t${i}`, created_at: "1716383021" },
+    }));
+    const { client } = makeClient([
+      [
+        "api/container/getIndex",
+        { body: JSON.stringify({ ok: 1, data: { cards: items } }) },
+      ],
+    ]);
+    const posts = await client.fetchPosts(FAKE_COOKIE, 1, { limit: 5 });
+    expect(posts).toHaveLength(5);
+  });
+
+  it("uses containerid=107603<uid>", async () => {
+    const { client, calls } = makeClient([
+      [
+        "api/container/getIndex",
+        { body: JSON.stringify({ ok: 1, data: { cards: [] } }) },
+      ],
+    ]);
+    await client.fetchPosts(FAKE_COOKIE, 99);
+    expect(calls[0].url).toContain("containerid=10760399");
+  });
+});
+
+// ─── fetchFavourites ───────────────────────────────────────────────────
+
+describe("WeiboApiClient.fetchFavourites", () => {
+  it("parses status nested rows", async () => {
+    const { client } = makeClient([
+      [
+        "api/favorites",
+        {
+          body: JSON.stringify({
+            ok: 1,
+            data: {
+              favorites: [
+                {
+                  favorited_time: "Sun Jan 12 14:00:00 +0800 2026",
+                  status: {
+                    mid: "FAV_001",
+                    text: "interesting <em>thing</em>",
+                    user: { screen_name: "@famous" },
+                  },
+                },
+              ],
+            },
+          }),
+        },
+      ],
+    ]);
+    const favs = await client.fetchFavourites(FAKE_COOKIE);
+    expect(favs).toHaveLength(1);
+    expect(favs[0]).toMatchObject({
+      mid: "FAV_001",
+      text: "interesting thing",
+      authorScreenName: "@famous",
+    });
+    expect(favs[0].favAt).toBeGreaterThan(0);
+  });
+
+  it("falls back to status.created_at when favorited_time absent", async () => {
+    const { client } = makeClient([
+      [
+        "api/favorites",
+        {
+          body: JSON.stringify({
+            ok: 1,
+            data: {
+              favorites: [
+                {
+                  status: {
+                    mid: "X",
+                    text: "y",
+                    created_at: "Sun Jan 12 13:45:00 +0800 2026",
+                  },
+                },
+              ],
+            },
+          }),
+        },
+      ],
+    ]);
+    const favs = await client.fetchFavourites(FAKE_COOKIE);
+    expect(favs[0].favAt).toBeGreaterThan(0);
+  });
+});
+
+// ─── fetchFollows ──────────────────────────────────────────────────────
+
+describe("WeiboApiClient.fetchFollows", () => {
+  it("parses users list", async () => {
+    const { client } = makeClient([
+      [
+        "api/friendships/friends",
+        {
+          body: JSON.stringify({
+            ok: 1,
+            data: {
+              users: [
+                {
+                  id: 42,
+                  screen_name: "Friend1",
+                  description: "hi",
+                  profile_image_url: "https://x.png",
+                },
+                { id: 0, screen_name: "Ghost" }, // skip
+                { id: 99, screen_name: "Friend2" },
+              ],
+            },
+          }),
+        },
+      ],
+    ]);
+    const fols = await client.fetchFollows(FAKE_COOKIE, 1234);
+    expect(fols).toHaveLength(2);
+    expect(fols[0].uid).toBe(42);
+    expect(fols[1].uid).toBe(99);
+    expect(fols[0].screenName).toBe("Friend1");
+  });
+
+  it("uid sent as vmid query param", async () => {
+    const { client, calls } = makeClient([
+      [
+        "api/friendships/friends",
+        { body: JSON.stringify({ ok: 1, data: { users: [] } }) },
+      ],
+    ]);
+    await client.fetchFollows(FAKE_COOKIE, 9999);
+    expect(calls[0].url).toContain("uid=9999");
+  });
+});
+
+// ─── error code propagation ─────────────────────────────────────────────
+
+describe("WeiboApiClient — error propagation", () => {
+  it("ok != 1 → returns [] + sets lastError", async () => {
+    const { client } = makeClient([
+      [
+        "api/container/getIndex",
+        { body: JSON.stringify({ ok: -100, msg: "anti-bot" }) },
+      ],
+    ]);
+    const r = await client.fetchPosts(FAKE_COOKIE, 1);
+    expect(r).toEqual([]);
+    expect(client.lastErrorCode).toBe(-100);
+    expect(client.lastErrorMessage).toBe("anti-bot");
+  });
+});