@chainlesschain/personal-data-hub 0.3.1 → 0.3.7

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");
+  });
+});

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

@@ -0,0 +1,201 @@
+"use strict";
+
+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-weibo-adb/collector");
+
+let stagingDir;
+
+beforeEach(() => {
+  stagingDir = mkdtempSync(join(tmpdir(), "cc-weibo-test-"));
+});
+
+afterEach(() => {
+  try {
+    rmSync(stagingDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+function makeFakeBridge({ cookieResult, throwOnInvoke } = {}) {
+  return {
+    invoke: vi.fn(async (_method) => {
+      if (throwOnInvoke) throw throwOnInvoke;
+      return cookieResult;
+    }),
+  };
+}
+
+function makeFakeApiClient({
+  uid = 1234567890,
+  posts = [],
+  favourites = [],
+  follows = [],
+  lastErrorCode = 0,
+  lastErrorMessage = null,
+} = {}) {
+  return {
+    fetchUid: vi.fn(async () => uid),
+    fetchPosts: vi.fn(async () => posts),
+    fetchFavourites: vi.fn(async () => favourites),
+    fetchFollows: vi.fn(async () => follows),
+    lastErrorCode,
+    lastErrorMessage,
+  };
+}
+
+describe("collect — happy path", () => {
+  it("invokes cookies, fetchUid, 3 endpoints, writes snapshot", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: {
+        cookie: "SUB=abc",
+        diagnostic: { cookieCount: 5, hasSub: true },
+      },
+    });
+    const apiClient = makeFakeApiClient({
+      uid: 1234567890,
+      posts: [{ mid: "P1", text: "p", createdAt: 1 }],
+      favourites: [{ mid: "F1", text: "f", favAt: 2 }],
+      follows: [{ uid: 99, screenName: "x", followedAt: 0 }],
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+
+    expect(bridge.invoke).toHaveBeenCalledWith("weibo.cookies");
+    expect(apiClient.fetchUid).toHaveBeenCalledWith("SUB=abc");
+    expect(apiClient.fetchPosts).toHaveBeenCalledWith(
+      "SUB=abc",
+      1234567890,
+      expect.any(Object),
+    );
+    expect(result.uid).toBe(1234567890);
+    expect(result.eventCounts).toEqual({
+      post: 1,
+      favourite: 1,
+      follow: 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.uidFetchFailed).toBe(false);
+  });
+});
+
+describe("collect — uid fetch failure (cookie expired)", () => {
+  it("returns empty-event snapshot + uidFetchFailed=true", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "SUB=expired", diagnostic: {} },
+    });
+    const apiClient = makeFakeApiClient({
+      uid: null,
+      lastErrorCode: -4,
+      lastErrorMessage: "non-json (cookie expired?)",
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.uid).toBe(null);
+    expect(result.uidFetchFailed).toBe(true);
+    expect(result.eventCounts.total).toBe(0);
+    expect(result.lastErrorCode).toBe(-4);
+    // fetchPosts/Favourites/Follows must NOT be called when uid failed
+    expect(apiClient.fetchPosts).not.toHaveBeenCalled();
+    // Snapshot file still written so downstream caller doesn't crash on
+    // missing inputPath
+    expect(existsSync(result.snapshotPath)).toBe(true);
+  });
+});
+
+describe("collect — failure modes", () => {
+  it("propagates bridge.invoke errors", async () => {
+    const bridge = makeFakeBridge({
+      throwOnInvoke: new Error("WEIBO_NO_ROOT: phone isn't rooted"),
+    });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(/WEIBO_NO_ROOT/);
+  });
+
+  it("throws TypeError when bridge missing invoke", async () => {
+    await expect(collect(null, { stagingDir })).rejects.toThrow(TypeError);
+    await expect(collect({}, { stagingDir })).rejects.toThrow(TypeError);
+  });
+
+  it("throws on malformed cookieResult", async () => {
+    const bridge = makeFakeBridge({ cookieResult: { cookie: null } });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(/malformed payload/);
+  });
+});
+
+describe("collect — partial result tolerance", () => {
+  it("0 events when uid OK but all 3 endpoints empty", async () => {
+    const bridge = makeFakeBridge({ cookieResult: { cookie: "SUB=a" } });
+    const apiClient = makeFakeApiClient();
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.eventCounts.total).toBe(0);
+    expect(existsSync(result.snapshotPath)).toBe(true);
+  });
+
+  it("partial event set when one endpoint fails", async () => {
+    const bridge = makeFakeBridge({ cookieResult: { cookie: "SUB=a" } });
+    const apiClient = makeFakeApiClient({
+      posts: [{ mid: "P", text: "x", createdAt: 1 }],
+      favourites: [], // simulated failure
+      follows: [{ uid: 1, screenName: "x" }],
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.eventCounts).toEqual({ post: 1, favourite: 0, follow: 1, total: 2 });
+  });
+});
+
+describe("collectAndSync", () => {
+  it("calls registry.syncAdapter + cleans up on success", async () => {
+    const bridge = makeFakeBridge({ cookieResult: { cookie: "SUB=a" } });
+    const apiClient = makeFakeApiClient({
+      posts: [{ mid: "P", createdAt: 1 }],
+    });
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (name, opts) => {
+        if (name !== "social-weibo") throw new Error("wrong name");
+        syncedPath = opts.inputPath;
+        return { adapter: name, status: "ok", rawCount: 1 };
+      }),
+    };
+    const report = await collectAndSync(bridge, registry, {
+      apiClient,
+      stagingDir,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.weibo.uid).toBe(1234567890);
+    expect(report.weibo.eventCounts.post).toBe(1);
+    expect(existsSync(syncedPath)).toBe(false);
+  });
+
+  it("cleanup even on syncAdapter throw", async () => {
+    const bridge = makeFakeBridge({ cookieResult: { cookie: "SUB=a" } });
+    const apiClient = makeFakeApiClient();
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (_n, opts) => {
+        syncedPath = opts.inputPath;
+        throw new Error("registry exploded");
+      }),
+    };
+    await expect(
+      collectAndSync(bridge, registry, { apiClient, stagingDir }),
+    ).rejects.toThrow("registry exploded");
+    expect(existsSync(syncedPath)).toBe(false);
+  });
+
+  it("rejects missing syncAdapter", async () => {
+    const bridge = makeFakeBridge({ cookieResult: { cookie: "SUB=a" } });
+    await expect(
+      collectAndSync(bridge, null, { apiClient: makeFakeApiClient() }),
+    ).rejects.toThrow(TypeError);
+  });
+});