@chainlesschain/personal-data-hub 0.3.1 → 0.3.7

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

@@ -0,0 +1,189 @@
+"use strict";
+
+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-weibo-adb/snapshot-builder");
+
+let tmpDir;
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "cc-weibo-snap-test-"));
+});
+afterEach(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+describe("buildSnapshot — schema", () => {
+  it("returns documented shape", () => {
+    const s = buildSnapshot({
+      uid: 1234567890,
+      displayName: "alice",
+      snapshottedAt: 1716383021000,
+    });
+    expect(s.schemaVersion).toBe(1);
+    expect(s.schemaVersion).toBe(SNAPSHOT_SCHEMA_VERSION);
+    expect(s.snapshottedAt).toBe(1716383021000);
+    expect(s.account).toEqual({ uid: "1234567890", displayName: "alice" });
+    expect(s.events).toEqual([]);
+  });
+
+  it("rejects non-positive uid", () => {
+    expect(() => buildSnapshot({ uid: 0 })).toThrow(TypeError);
+    expect(() => buildSnapshot({ uid: -1 })).toThrow(TypeError);
+    expect(() => buildSnapshot({})).toThrow(TypeError);
+  });
+
+  it("defaults displayName + snapshottedAt", () => {
+    const before = Date.now();
+    const s = buildSnapshot({ uid: 1 });
+    const after = Date.now();
+    expect(s.account.displayName).toBe("");
+    expect(s.snapshottedAt).toBeGreaterThanOrEqual(before);
+    expect(s.snapshottedAt).toBeLessThanOrEqual(after);
+  });
+});
+
+describe("buildSnapshot — events", () => {
+  it("maps posts → kind=post", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      posts: [
+        {
+          mid: "M1",
+          text: "hi",
+          createdAt: 1716383021000,
+          source: "iPhone",
+          repostsCount: 5,
+          commentsCount: 10,
+          likesCount: 100,
+          picCount: 2,
+        },
+      ],
+    });
+    expect(s.events).toHaveLength(1);
+    expect(s.events[0]).toMatchObject({
+      kind: "post",
+      id: "post-M1",
+      capturedAt: 1716383021000,
+      text: "hi",
+      mid: "M1",
+      source: "iPhone",
+      repostsCount: 5,
+      commentsCount: 10,
+      likesCount: 100,
+      picCount: 2,
+    });
+  });
+
+  it("maps favourites → kind=favourite", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      favourites: [
+        { mid: "F1", text: "fav text", favAt: 1716383022000, authorScreenName: "x" },
+      ],
+    });
+    expect(s.events[0]).toMatchObject({
+      kind: "favourite",
+      id: "fav-F1",
+      capturedAt: 1716383022000,
+      mid: "F1",
+      authorScreenName: "x",
+    });
+  });
+
+  it("maps follows → kind=follow with snapshottedAt fallback", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      snapshottedAt: 999,
+      follows: [
+        {
+          uid: 42,
+          screenName: "Friend",
+          description: "hi",
+          avatarUrl: "https://x.png",
+          followedAt: 0, // /api/friendships/friends doesn't return follow time
+        },
+      ],
+    });
+    expect(s.events[0]).toMatchObject({
+      kind: "follow",
+      id: "follow-42",
+      uid: 42,
+      screenName: "Friend",
+      capturedAt: 999, // fallback to snapshottedAt
+    });
+  });
+
+  it("uses index fallback id when mid/uid missing", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      posts: [{ text: "no mid" }],
+      favourites: [{ text: "no mid" }],
+      follows: [{ screenName: "no uid" }],
+    });
+    expect(s.events.map((e) => e.id)).toEqual(["post-0", "fav-0", "follow-0"]);
+  });
+
+  it("preserves order post → favourite → follow", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      posts: [{ mid: "P", createdAt: 1 }],
+      favourites: [{ mid: "F", favAt: 2 }],
+      follows: [{ uid: 1, followedAt: 3 }],
+    });
+    expect(s.events.map((e) => e.kind)).toEqual(["post", "favourite", "follow"]);
+  });
+
+  it("handles non-array fields", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      posts: "not array",
+      favourites: null,
+      follows: {},
+    });
+    expect(s.events).toEqual([]);
+  });
+
+  it("skips null/non-object items", () => {
+    const s = buildSnapshot({
+      uid: 1,
+      posts: [null, { mid: "P", createdAt: 1 }, "junk"],
+    });
+    expect(s.events).toHaveLength(1);
+  });
+});
+
+describe("writeSnapshotJson + cleanupSnapshotJson", () => {
+  it("writes to default tmpdir", () => {
+    const s = buildSnapshot({ uid: 1 });
+    const p = writeSnapshotJson(s);
+    expect(existsSync(p)).toBe(true);
+    expect(p).toContain("cc-weibo-snapshot-");
+    const parsed = JSON.parse(readFileSync(p, "utf-8"));
+    expect(parsed.schemaVersion).toBe(1);
+    cleanupSnapshotJson(p);
+    expect(existsSync(p)).toBe(false);
+  });
+
+  it("rejects path separators in fileName", () => {
+    expect(() => writeSnapshotJson({ schemaVersion: 1 }, { fileName: "../evil.json" })).toThrow(
+      /must be a basename/,
+    );
+  });
+
+  it("cleanupSnapshotJson tolerates missing / null", () => {
+    cleanupSnapshotJson(null);
+    cleanupSnapshotJson(join(tmpDir, "nonexistent.json"));
+  });
+});

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

@@ -0,0 +1,207 @@
+"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-xiaohongshu-adb/collector");
+
+let stagingDir;
+
+beforeEach(() => {
+  stagingDir = mkdtempSync(join(tmpdir(), "cc-xhs-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({
+  me = { userId: "5e8c8f7e1234abcdef", nickname: "Alice" },
+  notes = [],
+  liked = [],
+  follows = [],
+  lastErrorCode = 0,
+  lastErrorMessage = null,
+} = {}) {
+  return {
+    fetchMe: vi.fn(async () => me),
+    fetchNotes: vi.fn(async () => notes),
+    fetchLiked: vi.fn(async () => liked),
+    fetchFollows: vi.fn(async () => follows),
+    lastErrorCode,
+    lastErrorMessage,
+  };
+}
+
+describe("collect — happy path", () => {
+  it("invokes cookies, fetchMe, 3 endpoints, writes snapshot", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: {
+        cookie: "a1=fp; web_session=tok",
+        a1: "fp",
+        diagnostic: { cookieCount: 5 },
+      },
+    });
+    const apiClient = makeFakeApiClient({
+      notes: [{ noteId: "N1", title: "note", createdAt: 1716383021000 }],
+      liked: [{ noteId: "L1", title: "liked" }],
+      follows: [{ userId: "U1", nickname: "Friend" }],
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+
+    expect(bridge.invoke).toHaveBeenCalledWith("xhs.cookies");
+    expect(apiClient.fetchMe).toHaveBeenCalledWith("a1=fp; web_session=tok");
+    expect(apiClient.fetchNotes).toHaveBeenCalledWith(
+      "a1=fp; web_session=tok",
+      "fp",
+      "5e8c8f7e1234abcdef",
+      expect.any(Object),
+    );
+    expect(result.userId).toBe("5e8c8f7e1234abcdef");
+    expect(result.nickname).toBe("Alice");
+    expect(result.eventCounts).toEqual({
+      note: 1,
+      liked: 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.meFetchFailed).toBe(false);
+  });
+});
+
+describe("collect — meFetchFailed (cookie expired)", () => {
+  it("returns empty-event snapshot + meFetchFailed=true", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "a1=fp; web_session=expired", a1: "fp" },
+    });
+    const apiClient = makeFakeApiClient({
+      me: null,
+      lastErrorCode: -7,
+      lastErrorMessage: "/user/me user_id blank",
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.userId).toBe(null);
+    expect(result.meFetchFailed).toBe(true);
+    expect(result.eventCounts.total).toBe(0);
+    expect(apiClient.fetchNotes).not.toHaveBeenCalled();
+    expect(existsSync(result.snapshotPath)).toBe(true);
+  });
+});
+
+describe("collect — failure modes", () => {
+  it("propagates bridge.invoke errors", async () => {
+    const bridge = makeFakeBridge({
+      throwOnInvoke: new Error("XHS_NO_ROOT: phone isn't rooted"),
+    });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(/XHS_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 (missing a1)", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "web_session=s", a1: null },
+    });
+    await expect(collect(bridge, { stagingDir })).rejects.toThrow(/malformed payload/);
+  });
+});
+
+describe("collect — partial result (X-S signing best-effort)", () => {
+  it("0 events when X-S sign rejected on all 3 endpoints", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "a1=fp; web_session=tok", a1: "fp" },
+    });
+    const apiClient = makeFakeApiClient({
+      // me OK (no X-S) but all 3 X-S endpoints return [] (461 rejection)
+      lastErrorCode: 461,
+      lastErrorMessage: "X-S validation failed",
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.eventCounts.total).toBe(0);
+    expect(result.lastErrorCode).toBe(461);
+    expect(result.meFetchFailed).toBe(false);
+  });
+
+  it("partial event set when one endpoint X-S signed OK", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "a1=fp; web_session=tok", a1: "fp" },
+    });
+    const apiClient = makeFakeApiClient({
+      notes: [{ noteId: "N1", title: "x" }],
+      liked: [], // 461
+      follows: [], // 461
+    });
+    const result = await collect(bridge, { apiClient, stagingDir });
+    expect(result.eventCounts).toEqual({ note: 1, liked: 0, follow: 0, total: 1 });
+  });
+});
+
+describe("collectAndSync", () => {
+  it("calls registry.syncAdapter + cleans up on success", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "a1=fp; web_session=tok", a1: "fp" },
+    });
+    const apiClient = makeFakeApiClient({
+      notes: [{ noteId: "N1" }],
+    });
+    let syncedPath = null;
+    const registry = {
+      syncAdapter: vi.fn(async (name, opts) => {
+        if (name !== "social-xiaohongshu") 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.xhs.userId).toBe("5e8c8f7e1234abcdef");
+    expect(report.xhs.eventCounts.note).toBe(1);
+    expect(existsSync(syncedPath)).toBe(false);
+  });
+
+  it("cleanup even on syncAdapter throw", async () => {
+    const bridge = makeFakeBridge({
+      cookieResult: { cookie: "a1=fp; web_session=tok", a1: "fp" },
+    });
+    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);
+  });
+});