@chainlesschain/personal-data-hub 0.4.3 → 0.4.5

package/__tests__/adapters/game-honor-of-kings-live.test.js

@@ -0,0 +1,230 @@
+/**
+ * FAMILY-23 v0.2 — game-honor-of-kings LIVE 营地 (Camp) fetcher tests.
+ * credential (accessToken+openid+role) → profile + battle-list → snapshot-shaped
+ * events + adapter live sync + defensive field extraction + error mapping.
+ * All network via injected fetch. Endpoint shapes are best-effort (see api-client
+ * header) — these tests pin the REQUEST CONSTRUCTION + PARSING contract, not the
+ * live server, which can't be verified here.
+ */
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const { HonorOfKingsAdapter } = require("../../lib");
+const {
+  HonorOfKingsApiClient,
+  pick,
+  toDurationMs,
+  toEpochMs,
+} = require("../../lib/adapters/game-honor-of-kings/api-client");
+const { validateBatch } = require("../../lib/batch");
+
+const CRED = {
+  accessToken: "tok-abc",
+  openid: "OPENID12345678",
+  acctype: "qc",
+  areaId: "1",
+  roleId: "900000001",
+};
+
+function makeFetch(routes, calls) {
+  return async (url, init) => {
+    let parsedBody = null;
+    try {
+      parsedBody = init && init.body ? JSON.parse(init.body) : null;
+    } catch (_e) {
+      parsedBody = init && init.body;
+    }
+    calls.push({ url, body: parsedBody, headers: (init && init.headers) || {} });
+    const route = routes.find((r) => url.includes(r.match));
+    if (!route) return { ok: false, status: 404, text: async () => "not mapped" };
+    return {
+      ok: route.status ? route.status >= 200 && route.status < 300 : true,
+      status: route.status || 200,
+      text: async () =>
+        typeof route.body === "string" ? route.body : JSON.stringify(route.body),
+    };
+  };
+}
+
+async function collect(iter) {
+  const out = [];
+  for await (const r of iter) out.push(r);
+  return out;
+}
+
+describe("honor-of-kings field-extraction helpers", () => {
+  it("pick returns first present non-empty value", () => {
+    expect(pick({ a: "", b: "x" }, ["a", "b"])).toBe("x");
+    expect(pick({ a: 0 }, ["a"])).toBe(0); // 0 is present
+    expect(pick({}, ["a"], "fb")).toBe("fb");
+  });
+
+  it("toDurationMs treats <1e7 as seconds, else ms; coerces numeric strings", () => {
+    expect(toDurationMs(1800)).toBe(1800000); // 30 min in seconds
+    expect(toDurationMs(1800000)).toBe(1800000); // already ms
+    expect(toDurationMs("900")).toBe(900000);
+    expect(toDurationMs(0)).toBe(0);
+    expect(toDurationMs("nope")).toBe(0);
+  });
+
+  it("toEpochMs coerces seconds/ms/date-string", () => {
+    expect(toEpochMs(1700000000)).toBe(1700000000000);
+    expect(toEpochMs(1700000000000)).toBe(1700000000000);
+    expect(toEpochMs("2023-11-14T22:13:20Z")).toBe(1700000000000);
+    expect(toEpochMs("bogus")).toBeNull();
+  });
+});
+
+describe("HonorOfKingsApiClient.fetchSnapshot — live (mocked fetch)", () => {
+  it("merges auth fields into each request + parses profile/battles defensively", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        {
+          match: "/play/profildetail",
+          body: {
+            returnCode: 0,
+            data: { role: { roleId: "900000001", roleName: "小明", level: 30, rankName: "钻石", logo: "u.png" } },
+          },
+        },
+        {
+          match: "/game/getbattlelist",
+          body: {
+            returnCode: 0,
+            data: {
+              list: [
+                { gameSeq: "g1", startTime: 1700000000, gametime: 900, mapName: "排位赛" },
+                { gameSeq: "g2", startTime: "1700003600", usedTime: 1200, modeName: "巅峰赛" },
+              ],
+            },
+          },
+        },
+      ],
+      calls,
+    );
+    const client = new HonorOfKingsApiClient({ fetch });
+    const result = await client.fetchSnapshot(CRED);
+    expect(result.account).toEqual({ uid: "900000001", displayName: "小明" });
+    const profile = result.events.find((e) => e.kind === "profile");
+    expect(profile).toMatchObject({ uid: "900000001", nickname: "小明", level: 30, rank: "钻石", avatarUrl: "u.png" });
+    const plays = result.events.filter((e) => e.kind === "play");
+    expect(plays).toHaveLength(2);
+    expect(plays[0]).toMatchObject({ durationMs: 900000, mode: "排位赛", startAt: 1700000000000 });
+    expect(plays[1]).toMatchObject({ durationMs: 1200000, mode: "巅峰赛", startAt: 1700003600000 });
+    // every request carried the OAuth auth fields.
+    for (const c of calls) {
+      expect(c.body.accessToken).toBe("tok-abc");
+      expect(c.body.openid).toBe("OPENID12345678");
+      expect(c.body.acctype).toBe("qc");
+      expect(c.headers["Content-Type"]).toContain("application/json");
+    }
+  });
+
+  it("handles alternate envelope/field names (result + roleInfo + battleList)", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        {
+          match: "/play/profildetail",
+          body: { result: 0, data: { roleInfo: { uid: "777", nickName: "阿强", roleLevel: 15, gradeName: "黄金" } } },
+        },
+        {
+          match: "/game/getbattlelist",
+          body: { result: 0, data: { battleList: [{ gameId: "b9", battleTime: 1700000000, gameDuration: 600, gameName: "5v5" }] } },
+        },
+      ],
+      calls,
+    );
+    const client = new HonorOfKingsApiClient({ fetch });
+    const result = await client.fetchSnapshot(CRED);
+    expect(result.account.displayName).toBe("阿强");
+    const profile = result.events.find((e) => e.kind === "profile");
+    expect(profile).toMatchObject({ uid: "777", level: 15, rank: "黄金" });
+    const play = result.events.find((e) => e.kind === "play");
+    expect(play).toMatchObject({ durationMs: 600000, mode: "5v5" });
+  });
+
+  it("include.play:false skips the battle-list call", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [{ match: "/play/profildetail", body: { returnCode: 0, data: { role: { roleId: "1", roleName: "x" } } } }],
+      calls,
+    );
+    const client = new HonorOfKingsApiClient({ fetch });
+    const result = await client.fetchSnapshot(CRED, { include: { play: false } });
+    expect(calls.some((c) => c.url.includes("getbattlelist"))).toBe(false);
+    expect(result.events.every((e) => e.kind !== "play")).toBe(true);
+  });
+
+  it("maps non-zero returnCode to null + lastError (e.g. token expired)", async () => {
+    const calls = [];
+    const fetch = makeFetch([{ match: "/play/profildetail", body: { returnCode: 1001, returnMsg: "登录态失效" } }], calls);
+    const client = new HonorOfKingsApiClient({ fetch });
+    expect(await client.fetchSnapshot(CRED)).toBeNull();
+    expect(client.lastError.code).toBe(1001);
+    expect(client.lastError.message).toContain("登录态失效");
+  });
+
+  it("missing accessToken/openid → null + lastError -1 (no network)", async () => {
+    const calls = [];
+    const client = new HonorOfKingsApiClient({ fetch: makeFetch([], calls) });
+    expect(await client.fetchSnapshot({ openid: "x" })).toBeNull();
+    expect(client.lastError.code).toBe(-1);
+    expect(calls).toHaveLength(0);
+  });
+
+  it("HTTP non-2xx → null + lastError with status", async () => {
+    const calls = [];
+    const fetch = makeFetch([{ match: "/play/profildetail", status: 500, body: "err" }], calls);
+    const client = new HonorOfKingsApiClient({ fetch });
+    expect(await client.fetchSnapshot(CRED)).toBeNull();
+    expect(client.lastError.code).toBe(500);
+  });
+});
+
+describe("HonorOfKingsAdapter — credential (live) sync mode", () => {
+  it("authenticate accepts a credential bundle; rejects incomplete", async () => {
+    const a = new HonorOfKingsAdapter();
+    expect((await a.authenticate({ credential: CRED })).mode).toBe("camp-token");
+    expect((await a.authenticate({ credential: { openid: "x" } })).ok).toBe(false);
+  });
+
+  it("version/capabilities reflect v0.2 live mode", () => {
+    const a = new HonorOfKingsAdapter();
+    expect(a.version).toBe("0.2.0");
+    expect(a.capabilities).toContain("sync:camp-token");
+  });
+
+  it("sync via credential yields profile+play raws → valid normalized batch", async () => {
+    const calls = [];
+    const fetch = makeFetch(
+      [
+        { match: "/play/profildetail", body: { returnCode: 0, data: { role: { roleId: "900000001", roleName: "小明", level: 30, rankName: "钻石" } } } },
+        { match: "/game/getbattlelist", body: { returnCode: 0, data: { list: [{ gameSeq: "g1", startTime: 1700000000, gametime: 1800, mapName: "排位赛" }] } } },
+      ],
+      calls,
+    );
+    const a = new HonorOfKingsAdapter();
+    const raws = await collect(a.sync({ credential: CRED, fetch }));
+    expect(raws.map((r) => r.kind).sort()).toEqual(["play", "profile"]);
+    const profileRaw = raws.find((r) => r.kind === "profile");
+    expect(profileRaw.originalId).toBe("hok:profile:profile-900000001");
+
+    for (const raw of raws) {
+      expect(validateBatch(a.normalize(raw)).valid).toBe(true);
+    }
+    const profileBatch = a.normalize(profileRaw);
+    expect(profileBatch.persons[0].identifiers["hok-uid"]).toEqual(["900000001"]);
+    expect(profileBatch.persons[0].extra.rank).toBe("钻石");
+    const playBatch = a.normalize(raws.find((r) => r.kind === "play"));
+    expect(playBatch.events[0].extra.durationMs).toBe(1800000);
+  });
+
+  it("sync via credential throws (mapped lastError) on API error", async () => {
+    const calls = [];
+    const fetch = makeFetch([{ match: "/play/profildetail", body: { returnCode: 1001, returnMsg: "登录态失效" } }], calls);
+    const a = new HonorOfKingsAdapter();
+    await expect(collect(a.sync({ credential: CRED, fetch }))).rejects.toThrow(/登录态失效|code 1001/);
+  });
+});

package/__tests__/adapters/messaging-whatsapp.test.js

@@ -0,0 +1,289 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  WhatsAppAdapter,
+  NAME,
+  VERSION,
+} = require("../../lib/adapters/messaging-whatsapp");
+
+function writeTmpDb() {
+  const p = path.join(
+    os.tmpdir(),
+    `cc-whatsapp-test-${crypto.randomUUID()}.db`,
+  );
+  fs.writeFileSync(p, "fake");
+  return p;
+}
+
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+function makeFakeDriverFactory(tables, log = {}) {
+  return () =>
+    class FakeDb {
+      constructor(dbPath, opts) {
+        log.opened = { dbPath, opts };
+      }
+      prepare(sql) {
+        for (const [needle, rows] of Object.entries(tables)) {
+          if (sql.includes(needle)) return { all: () => rows };
+        }
+        throw new Error(`no such table in: ${sql}`);
+      }
+      close() {
+        log.closed = true;
+      }
+    };
+}
+
+describe("constants", () => {
+  it("exposes name/version + high sensitivity & legal gate", () => {
+    expect(NAME).toBe("messaging-whatsapp");
+    expect(VERSION).toBe("0.6.0");
+    const a = new WhatsAppAdapter();
+    expect(a.dataDisclosure.sensitivity).toBe("high");
+    expect(a.dataDisclosure.legalGate).toBe(true);
+  });
+});
+
+describe("authenticate", () => {
+  it("fails DB_NOT_PULLED without a real db file", async () => {
+    const a = new WhatsAppAdapter();
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("DB_NOT_PULLED");
+  });
+
+  it("ok when dbPath exists (inputPath alias too)", async () => {
+    const p = writeTmpDb();
+    try {
+      const a = new WhatsAppAdapter({ account: { phone: "8613800138000" } });
+      expect(await a.authenticate({ inputPath: p })).toEqual({
+        ok: true,
+        account: "8613800138000",
+        mode: "snapshot-file",
+      });
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+});
+
+describe("sync — fake sqlite driver", () => {
+  const JID_ROW = {
+    _id: 1,
+    user: "8613800138000",
+    raw_string: "8613800138000@s.whatsapp.net",
+    display_name: "Alice",
+  };
+  const CHAT_ROW = { _id: 2, subject: "Family group" };
+  const MSG_ROW = {
+    _id: 3,
+    key_remote_jid: "8613800138000@s.whatsapp.net",
+    from_me: 1,
+    text_data: "hello",
+    timestamp: 1716383021, // seconds
+  };
+  const CALL_ROW = {
+    _id: 4,
+    jid_row_id: 1,
+    from_me: 0,
+    video_call: 1,
+    duration: 65,
+    timestamp: 1716383021000,
+  };
+
+  it("yields contact/chat/message/call rows with kind tags, closes db", async () => {
+    const p = writeTmpDb();
+    const log = {};
+    try {
+      const a = new WhatsAppAdapter({
+        dbPath: p,
+        dbDriverFactory: makeFakeDriverFactory(
+          {
+            "FROM jid": [JID_ROW],
+            "FROM chat": [CHAT_ROW],
+            "FROM message ": [MSG_ROW],
+            "FROM call_log": [CALL_ROW],
+          },
+          log,
+        ),
+      });
+      const items = await collect(a.sync({}));
+      expect(items.map((i) => i.originalId)).toEqual([
+        "jid-1",
+        "chat-2",
+        "msg-3",
+        "call-4",
+      ]);
+      expect(items.map((i) => i.payload.kind)).toEqual([
+        "contact",
+        "chat",
+        "message",
+        "call",
+      ]);
+      // message timestamp seconds → ms
+      expect(items[2].capturedAt).toBe(1716383021 * 1000);
+      expect(log.opened.opts).toEqual({ readonly: true });
+      expect(log.closed).toBe(true);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("falls back to legacy `messages` table when `message` missing", async () => {
+    const p = writeTmpDb();
+    try {
+      const a = new WhatsAppAdapter({
+        dbPath: p,
+        dbDriverFactory: makeFakeDriverFactory({
+          "FROM jid": [],
+          "FROM chat": [],
+          "FROM messages ": [MSG_ROW],
+          "FROM call_log": [],
+        }),
+      });
+      const items = await collect(a.sync({}));
+      expect(items).toHaveLength(1);
+      expect(items[0].payload.kind).toBe("message");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("returns silently when db file missing", async () => {
+    const a = new WhatsAppAdapter({
+      dbPath: path.join(os.tmpdir(), "nonexistent-wa.db"),
+      dbDriverFactory: makeFakeDriverFactory({}),
+    });
+    expect(await collect(a.sync({}))).toEqual([]);
+  });
+});
+
+describe("normalize", () => {
+  const a = new WhatsAppAdapter();
+
+  it("personal jid → contact person with digits-only phone identifier", () => {
+    const batch = a.normalize({
+      originalId: "jid-1",
+      payload: {
+        kind: "contact",
+        row: {
+          _id: 1,
+          user: "+86 138-0013-8000",
+          raw_string: "8613800138000@s.whatsapp.net",
+          display_name: "Alice",
+        },
+      },
+    });
+    const person = batch.persons[0];
+    expect(person.subtype).toBe("contact");
+    expect(person.names).toEqual(["Alice", "+86 138-0013-8000"]);
+    expect(person.identifiers).toEqual({ phone: ["8613800138000"] });
+    expect(batch.topics).toEqual([]);
+  });
+
+  it("group jid (@g.us) → topic, not person", () => {
+    const batch = a.normalize({
+      originalId: "jid-9",
+      payload: {
+        kind: "contact",
+        row: {
+          _id: 9,
+          raw_string: "1234-5678@g.us",
+          display_name: "Family group",
+        },
+      },
+    });
+    expect(batch.persons).toEqual([]);
+    expect(batch.topics[0]).toMatchObject({
+      id: "topic-whatsapp-1234-5678@g.us",
+      name: "Family group",
+    });
+  });
+
+  it("chat row → topic named by subject", () => {
+    const batch = a.normalize({
+      originalId: "chat-2",
+      payload: { kind: "chat", row: { _id: 2, subject: "Work chat" } },
+    });
+    expect(batch.topics[0]).toMatchObject({
+      id: "topic-whatsapp-chat-2",
+      name: "Work chat",
+    });
+  });
+
+  it("outgoing message → message event from person-self, title truncated to 80", () => {
+    const longText = "x".repeat(200);
+    const batch = a.normalize({
+      originalId: "msg-3",
+      payload: {
+        kind: "message",
+        row: {
+          _id: 3,
+          key_remote_jid: "8613800138000@s.whatsapp.net",
+          from_me: 1,
+          text_data: longText,
+          timestamp: 1716383021000,
+        },
+      },
+    });
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("message");
+    expect(ev.actor).toBe("person-self");
+    expect(ev.occurredAt).toBe(1716383021000);
+    expect(ev.content.title).toHaveLength(80);
+    expect(ev.content.text).toHaveLength(200);
+    expect(ev.extra.isOutgoing).toBe(true);
+  });
+
+  it("incoming empty message → '(空)' title, actor from jid", () => {
+    const batch = a.normalize({
+      originalId: "msg-4",
+      payload: {
+        kind: "message",
+        row: {
+          _id: 4,
+          key_remote_jid: "86139@s.whatsapp.net",
+          from_me: 0,
+          timestamp: 1716383021000,
+        },
+      },
+    });
+    const ev = batch.events[0];
+    expect(ev.content.title).toBe("(空)");
+    expect(ev.actor).toBe("person-whatsapp-86139@s.whatsapp.net");
+    expect(ev.extra.isOutgoing).toBe(false);
+  });
+
+  it("incoming video call → call event with duration/isVideo extras", () => {
+    const batch = a.normalize({
+      originalId: "call-5",
+      payload: {
+        kind: "call",
+        row: {
+          _id: 5,
+          jid_row_id: 1,
+          from_me: 0,
+          video_call: 1,
+          duration: 65,
+          timestamp: 1716383021000,
+        },
+      },
+    });
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("call");
+    expect(ev.content.title).toBe("WhatsApp call (video)");
+    expect(ev.actor).toBe("person-whatsapp-1");
+    expect(ev.extra).toMatchObject({ duration: 65, isVideo: true, fromMe: false });
+  });
+});