@chainlesschain/personal-data-hub 0.3.6 → 0.3.8

package/__tests__/adapters/social-kuaishou-adb-cookies-extension.test.js

@@ -0,0 +1,141 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  createKuaishouCookiesExtension,
+  KUAISHOU_COOKIES_REMOTE_PATH,
+  KUAISHOU_COOKIE_HOST_DOMAIN,
+  KUAISHOU_LOGIN_COOKIES,
+  assembleKuaishouCookieHeader,
+  _internals,
+} = require("../../lib/adapters/social-kuaishou-adb/cookies-extension");
+
+describe("constants", () => {
+  it("path points to com.smile.gifmaker WebView cookies", () => {
+    expect(KUAISHOU_COOKIES_REMOTE_PATH).toBe(
+      "/data/data/com.smile.gifmaker/app_webview/Default/Cookies",
+    );
+  });
+
+  it("host domain is kuaishou.com", () => {
+    expect(KUAISHOU_COOKIE_HOST_DOMAIN).toBe("kuaishou.com");
+  });
+
+  it("login cookies enumerated (userId OR kuaishou.web.cp.api_ph)", () => {
+    expect([...KUAISHOU_LOGIN_COOKIES]).toEqual([
+      "userId",
+      "kuaishou.web.cp.api_ph",
+    ]);
+  });
+});
+
+describe("pickUidFromCookieMap", () => {
+  const make = (entries) =>
+    new Map(entries.map(([k, v]) => [k, { value: v }]));
+
+  it("prefers direct userId cookie", () => {
+    const map = make([
+      ["userId", "12345"],
+      ["kuaishou.web.cp.api_ph", encodeURIComponent('{"user_id":99999}')],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("12345");
+  });
+
+  it("falls back to api_ph nested user_id", () => {
+    const map = make([
+      ["kuaishou.web.cp.api_ph", encodeURIComponent('{"user_id":"55555"}')],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("55555");
+  });
+
+  it("falls back to api_ph nested uid alternate", () => {
+    const map = make([
+      ["kuaishou.web.cp.api_ph", encodeURIComponent('{"uid":"77777"}')],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("77777");
+  });
+
+  it("handles api_ph not URL-encoded (raw)", () => {
+    const map = make([["kuaishou.web.cp.api_ph", '{"user_id":"33333"}']]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("33333");
+  });
+
+  it("returns null for userId=0 (guest sentinel)", () => {
+    const map = make([["userId", "0"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+
+  it("returns null when only anti-bot cookies present", () => {
+    const map = make([["did", "anonid"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+});
+
+describe("assembleKuaishouCookieHeader", () => {
+  const mkCookie = (name, value, hostKey = ".kuaishou.com") => ({
+    name,
+    value,
+    hostKey,
+  });
+
+  it("builds header from direct userId cookie", () => {
+    const cookies = [
+      mkCookie("userId", "12345"),
+      mkCookie("did", "anon"),
+    ];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toContain("userId=12345");
+    expect(r.uid).toBe("12345");
+    expect(r.missing).toEqual([]);
+  });
+
+  it("builds header from api_ph alone (no direct userId)", () => {
+    const cookies = [
+      mkCookie(
+        "kuaishou.web.cp.api_ph",
+        encodeURIComponent('{"user_id":"55555","user_name":"Alice"}'),
+      ),
+    ];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toContain("kuaishou.web.cp.api_ph=");
+    expect(r.uid).toBe("55555");
+    expect(r.missing).toEqual([]);
+  });
+
+  it("returns null header when no login cookie present", () => {
+    const cookies = [mkCookie("did", "anon"), mkCookie("ttwid", "x")];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toBe(null);
+    expect(r.uid).toBe(null);
+    expect(r.missing).toEqual(["userId", "kuaishou.web.cp.api_ph"]);
+  });
+
+  it("dedupes by longest hostKey when same name appears twice", () => {
+    const cookies = [
+      mkCookie("userId", "subdomain-val", "www.kuaishou.com"),
+      mkCookie("userId", "wildcard-val", ".kuaishou.com"),
+    ];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toContain("userId=subdomain-val");
+  });
+
+  it("throws TypeError on non-array input", () => {
+    expect(() => assembleKuaishouCookieHeader(null)).toThrow(TypeError);
+    expect(() => assembleKuaishouCookieHeader("x")).toThrow(TypeError);
+  });
+});
+
+describe("createKuaishouCookiesExtension", () => {
+  it("rejects when ctx missing required functions", async () => {
+    const ext = createKuaishouCookiesExtension();
+    await expect(ext({}, {})).rejects.toThrow(/ctx must provide/);
+  });
+
+  it("rejects when adb is not a function", async () => {
+    const ext = createKuaishouCookiesExtension();
+    await expect(
+      ext({}, { adb: null, pickDevice: () => "serial" }),
+    ).rejects.toThrow(/ctx must provide/);
+  });
+});

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

@@ -0,0 +1,178 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-kuaishou-adb/snapshot-builder");
+
+describe("SNAPSHOT_SCHEMA_VERSION", () => {
+  it("is 1 (matches existing social-kuaishou adapter)", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+});
+
+describe("buildSnapshot", () => {
+  it("throws on missing uid", () => {
+    expect(() => buildSnapshot({})).toThrow(/uid must be a non-empty string/);
+  });
+
+  it("emits profile event from input.profile", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      profile: {
+        nickname: "Alice",
+        kuaishouId: "alice_ks",
+        avatarUrl: "https://a/x.jpg",
+        sex: "F",
+        city: "Beijing",
+      },
+      snapshottedAt: 1716383021000,
+    });
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.account).toEqual({ uid: "12345", displayName: "" });
+    const prof = snap.events.find((e) => e.kind === "profile");
+    expect(prof).toMatchObject({
+      kind: "profile",
+      id: "profile-12345",
+      uid: "12345",
+      nickname: "Alice",
+      kuaishouId: "alice_ks",
+      city: "Beijing",
+    });
+  });
+
+  it("emits watch events with photo metadata", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      watch: [
+        {
+          photoId: "P1",
+          caption: "Funny vid",
+          duration: 30,
+          authorId: "A1",
+          authorName: "Auth1",
+          viewedAt: 1716000000000,
+        },
+      ],
+    });
+    const w = snap.events.filter((e) => e.kind === "watch");
+    expect(w).toHaveLength(1);
+    expect(w[0]).toMatchObject({
+      kind: "watch",
+      id: "photo-P1",
+      capturedAt: 1716000000000,
+      photoId: "P1",
+      caption: "Funny vid",
+      duration: 30,
+      authorId: "A1",
+      authorName: "Auth1",
+    });
+  });
+
+  it("emits collect events with self as author", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      displayName: "Alice",
+      collect: [{ photoId: "C1", caption: "My vid", postedAt: 1716100000000 }],
+    });
+    const c = snap.events.filter((e) => e.kind === "collect");
+    expect(c).toHaveLength(1);
+    expect(c[0]).toMatchObject({
+      kind: "collect",
+      id: "collect-C1",
+      capturedAt: 1716100000000,
+      photoId: "C1",
+      caption: "My vid",
+      authorId: "12345", // self
+      authorName: "Alice",
+    });
+  });
+
+  it("emits search events with keyword:ts id", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      search: [{ keyword: "AI", searchedAt: 1716200000000 }],
+    });
+    const s = snap.events.find((e) => e.kind === "search");
+    expect(s).toMatchObject({
+      kind: "search",
+      id: "search-AI:1716200000000",
+      capturedAt: 1716200000000,
+      keyword: "AI",
+      searchAt: 1716200000000,
+    });
+  });
+
+  it("ignores entries missing photoId / keyword", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      watch: [{ caption: "no photoId" }, { photoId: "OK" }],
+      collect: [{ caption: "no photoId" }],
+      search: [{ keyword: "" }, { keyword: "good" }],
+    });
+    expect(snap.events.filter((e) => e.kind === "watch")).toHaveLength(1);
+    expect(snap.events.filter((e) => e.kind === "collect")).toHaveLength(0);
+    expect(snap.events.filter((e) => e.kind === "search")).toHaveLength(1);
+  });
+
+  it("falls back to snapshottedAt when event lacks timestamp", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      watch: [{ photoId: "P" }],
+      snapshottedAt: 1716000000000,
+    });
+    expect(snap.events[0].capturedAt).toBe(1716000000000);
+  });
+
+  it("emits all 4 kinds at once", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      profile: { nickname: "Alice" },
+      watch: [{ photoId: "W1" }],
+      collect: [{ photoId: "C1" }],
+      search: [{ keyword: "kw1", searchedAt: 1 }],
+    });
+    expect(snap.events).toHaveLength(4);
+    expect(snap.events.map((e) => e.kind).sort()).toEqual([
+      "collect",
+      "profile",
+      "search",
+      "watch",
+    ]);
+  });
+});
+
+describe("writeSnapshotJson + cleanupSnapshotJson", () => {
+  it("writes valid JSON", () => {
+    const snap = buildSnapshot({ uid: "1", profile: { nickname: "A" } });
+    const full = writeSnapshotJson(snap);
+    try {
+      expect(fs.existsSync(full)).toBe(true);
+      const round = JSON.parse(fs.readFileSync(full, "utf-8"));
+      expect(round.account.uid).toBe("1");
+    } finally {
+      cleanupSnapshotJson(full);
+    }
+  });
+
+  it("rejects fileName with path separator", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(() =>
+      writeSnapshotJson(snap, { fileName: "../escape.json" }),
+    ).toThrow(/basename, not a path/);
+  });
+
+  it("cleanup tolerates missing file", () => {
+    expect(() => cleanupSnapshotJson(null)).not.toThrow();
+    expect(() =>
+      cleanupSnapshotJson(path.join(os.tmpdir(), "nonexistent-ks.json")),
+    ).not.toThrow();
+  });
+});