hridoy-ultimate 9.0.0 → 9.0.2

package/test/integration/mqtt-lifecycle.test.js

@@ -1,195 +0,0 @@
-"use strict";
-/**
- * MOCKED integration tests: real listenMqtt/connectMqtt/emitAuth code driven
- * against a fake mqtt client (test/helpers/stub-modules.js). They prove lifecycle
- * logic, ordering and cleanup. They do NOT prove Facebook accepts the traffic.
- * Set HRIDOY_TEST_ROOT=<other package dir> to run the same file against another tree
- * (used to demonstrate the regressions fail on the original 1.1.9 code).
- */
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const path = require("path");
-const os = require("os");
-const fs = require("fs");
-const root = process.env.HRIDOY_TEST_ROOT || path.join(__dirname, "..", "..");
-const stubs = require("../helpers/stub-modules");
-stubs.install();
-process.chdir(fs.mkdtempSync(path.join(os.tmpdir(), "hridoy-test-"))); // library creates ./Fca_Database on import
-
-const tick = () => new Promise((r) => setImmediate(r));
-const flush = async (n = 6) => { for (let i = 0; i < n; i++) await tick(); };
-
-// stopListening uses setTimeout internally; when timers are mocked we must tick them.
-async function stop(s, t) {
-  let done = false;
-  const p = new Promise((r) => s.emitter.stopListening(() => { done = true; r(); }));
-  for (let i = 0; i < 50 && !done; i++) {
-    if (t && t.mock && t.mock.timers && t.mock.timers.tick) { try { t.mock.timers.tick(10); } catch (_) { /* timers not mocked */ } }
-    await tick();
-  }
-  await p;
-}
-
-function setup(opts = {}) {
-  if (opts.t) opts.t.mock.timers.enable({ apis: ["setTimeout", "setInterval"] }); // BEFORE listen so its timers are mocked
-  stubs.purge(root);
-  stubs.FakeMqttClient.instances.length = 0;
-  const calls = { get: 0, post: 0 };
-  const defaultFuncs = {
-    get: () => { calls.get++; return Promise.resolve({ data: "" }); },
-    post: () => { calls.post++; return Promise.reject(new Error("network down (test)")); }
-  };
-  const api = { getCookies: () => "c_user=1; xs=abc", refreshFb_dtsg: () => Promise.resolve() };
-  const ctx = {
-    userID: "100000000000001", clientId: "abcd1234", loggedIn: true, firstListen: true, lastSeqId: 42,
-    globalOptions: Object.assign({ autoReconnect: true, emitReady: true, userAgent: "UA" }, opts.globalOptions || {}),
-    tasks: new Map(), _mqttOpt: opts.mqtt || {}
-  };
-  const factory = require(path.join(root, "src/api/socket/listenMqtt.js"));
-  const listen = factory(defaultFuncs, api, ctx, opts.mqtt);
-  const events = [];
-  const emitter = listen((err, msg) => events.push({ err, msg }), opts.listenOptions);
-  const clients = stubs.FakeMqttClient.instances;
-  return { ctx, api, calls, events, emitter, clients, listen, defaultFuncs };
-}
-
-test("[mocked] sync queue is published only after every SUBACK", async (t) => {
-  const s = setup();
-  assert.equal(s.clients.length, 1);
-  const c = s.clients[0];
-  c.simulateConnect();
-  assert.equal(c.published.filter((p) => p.topic.startsWith("/messenger_sync")).length, 0, "must not publish before SUBACK");
-  await flush();
-  const log = c.log;
-  const firstPublish = log.findIndex((e) => e.startsWith("publish:/messenger_sync"));
-  const lastSuback = log.map((e, i) => (e.startsWith("suback:") ? i : -1)).filter((i) => i >= 0).pop();
-  assert.ok(firstPublish > -1, "sync publish happened");
-  assert.ok(lastSuback < firstPublish, `SUBACKs (${lastSuback}) must precede first publish (${firstPublish}): ${log.join(",")}`);
-  await stop(s, t);
-});
-
-test("[mocked] reconnect after socket close uses backoff, then recovers", async (t) => {
-  const s = setup({ mqtt: { reconnectDelayMs: 1000, reconnectJitter: 0, maxReconnectAttempts: 5 } });
-  s.clients[0].simulateConnect(); await flush();
-  t.mock.timers.enable({ apis: ["setTimeout"] });
-  s.clients[0].simulateClose();
-  assert.ok(s.ctx._reconnectTimer, "reconnect timer armed");
-  t.mock.timers.tick(999); assert.equal(s.clients.length, 1, "not before the delay");
-  t.mock.timers.tick(1); assert.equal(s.clients.length, 2, "reconnected after 1000ms");
-  // second failure waits twice as long
-  s.clients[1].simulateConnect(); await flush();
-  s.clients[1].simulateClose();
-  t.mock.timers.tick(1999); assert.equal(s.clients.length, 2);
-  t.mock.timers.tick(1); assert.equal(s.clients.length, 3, "second attempt after 2000ms (backoff doubled)");
-  t.mock.timers.reset();
-  await stop(s, t);
-});
-
-test("[mocked] stopListening during a cycle must not be revived by a pending retry (race regression)", async (t) => {
-  // Original 1.1.9: after stopListening() completed, endQuietly reset _ending=false and the untracked
-  // reconnect/getSeqID retry timers kept firing (observed: 30 getSeqID calls + a session refresh in 60s).
-  const s = setup({ t, mqtt: { cycleMs: 1000, reconnectDelayMs: 2000, reconnectJitter: 0 } });
-  s.clients[0].simulateConnect(); await flush();
-  t.mock.timers.tick(1000);                               // auto-cycle fires -> forceCycle
-  for (let i = 0; i < 8; i++) { await tick(); t.mock.timers.tick(5); }
-  assert.equal(s.clients[0].ended, true, "precondition: the cycle really started");
-  await stop(s, t);                                       // user stops inside the reconnect window
-  const before = { get: s.calls.get, post: s.calls.post, n: s.clients.length };
-  for (let i = 0; i < 30; i++) { t.mock.timers.tick(2000); await tick(); await tick(); }
-  assert.equal(s.calls.get, before.get, "no session refresh after stop");
-  assert.equal(s.calls.post, before.post, "no getSeqID retries after stop");
-  assert.equal(s.clients.length, before.n, "no new MQTT client after stop");
-});
-
-test("[mocked] stopListening clears timers, ends the client and is safe to call twice", async (t) => {
-  const s = setup();
-  s.clients[0].simulateConnect(); await flush();
-  await stop(s, t);
-  assert.equal(s.clients[0].ended, true);
-  assert.equal(s.ctx.mqttClient, undefined);
-  for (const k of ["_heartbeatInterval", "_sessionKeeperInterval", "_reconnectTimer", "_rTimeout", "_autoCycleTimer"]) {
-    assert.ok(!s.ctx[k], `${k} cleared`);
-  }
-  await stop(s, t); // second call: must complete, not hang/throw
-});
-
-test("[mocked] late socket 'error' after stopListening does not throw", async (t) => {
-  const s = setup();
-  s.clients[0].simulateConnect(); await flush();
-  await stop(s, t);
-  assert.doesNotThrow(() => s.clients[0].emit("error", new Error("late ECONNRESET")));
-});
-
-test("[mocked] calling listen twice replaces the old client (no duplicate connection)", async (t) => {
-  const s = setup();
-  s.clients[0].simulateConnect(); await flush();
-  const second = s.listen(() => {});
-  assert.equal(s.clients.length, 2);
-  assert.equal(s.clients[0].ended, true, "old client ended");
-  assert.equal(s.ctx.mqttClient, s.clients[1]);
-  // events from the stale client are inert
-  const timersBefore = s.ctx._reconnectTimer;
-  s.clients[0].simulateClose();
-  assert.equal(s.ctx._reconnectTimer, timersBefore, "stale close must not schedule a reconnect");
-  await stop({ emitter: second }, t);
-});
-
-test("[mocked] gives up after maxReconnectAttempts and reports stop_listen (no infinite loop)", async (t) => {
-  const s = setup({ mqtt: { reconnectDelayMs: 10, reconnectJitter: 0, maxReconnectAttempts: 2 } });
-  t.mock.timers.enable({ apis: ["setTimeout"] });
-  s.clients[0].simulateClose(); t.mock.timers.tick(10);            // attempt 1
-  assert.equal(s.clients.length, 2);
-  s.clients[1].simulateClose(); t.mock.timers.tick(20);            // attempt 2
-  assert.equal(s.clients.length, 3);
-  s.clients[2].simulateClose();                                     // budget exhausted
-  t.mock.timers.tick(100000);
-  assert.equal(s.clients.length, 3, "no further reconnects");
-  const stop = s.events.find((e) => e.err && e.err.type === "stop_listen");
-  assert.ok(stop, "stop_listen surfaced to the caller: " + JSON.stringify(s.events.map((e) => e.err && e.err.type)));
-  t.mock.timers.reset();
-});
-
-test("[mocked] a healthy first sync resets the backoff counter", async (t) => {
-  const s = setup({ globalOptions: { emitReady: true } });
-  const c = s.clients[0];
-  s.ctx._reconnectAttempt = 4;
-  c.simulateConnect(); await flush();
-  assert.equal(typeof s.ctx.tmsWait, "function");
-  c.emit("message", "/t_ms", Buffer.from(JSON.stringify({ firstDeltaSeqId: 1, syncToken: "tok", deltas: [] })));
-  assert.equal(s.ctx._reconnectAttempt, 0);
-  assert.ok(s.events.some((e) => e.err && e.err.type === "ready"), "ready event emitted: " + JSON.stringify(s.events));
-  await stop(s, t);
-});
-
-test("[mocked] humanizer middleware is NOT installed by default, and is when opted in", async (t) => {
-  let s = setup();
-  assert.equal(s.api.listMiddleware().length, 0, "default: no hidden middleware");
-  await stop(s, t);
-  s = setup({ globalOptions: { humanize: true } });
-  assert.ok(JSON.stringify(s.api.listMiddleware()).includes("humanizer"), "opt-in installs it");
-  await stop(s, t);
-});
-
-test("[mocked] emitAuth stops everything and reports account_inactive", async (t) => {
-  const s = setup();
-  s.clients[0].simulateConnect(); await flush();
-  const createEmitAuth = require(path.join(root, "src/api/socket/core/emitAuth"));
-  const seen = [];
-  createEmitAuth({ logger: () => {} })(s.ctx, s.api, (e) => seen.push(e), "not_logged_in", "test");
-  assert.equal(seen[0].type, "account_inactive");
-  assert.equal(s.ctx.loggedIn, false);
-  assert.equal(s.ctx.mqttClient, undefined);
-  assert.ok(!s.ctx._heartbeatInterval && !s.ctx._sessionKeeperInterval && !s.ctx._reconnectTimer);
-  assert.doesNotThrow(() => s.clients[0].emit("error", new Error("late")));
-});
-
-test("[mocked] listen(callback, options) applies reconnect options per call", async (t) => {
-  const s = setup({ t, listenOptions: { reconnectDelayMs: 50, reconnectJitter: 0, maxReconnectAttempts: 1 } });
-  assert.equal(s.ctx._mqttOpt.maxReconnectAttempts, 1);
-  assert.equal(s.ctx._mqttOpt.reconnectDelayMs, 50);
-  s.clients[0].simulateClose(); t.mock.timers.tick(50);
-  assert.equal(s.clients.length, 2);
-  s.clients[1].simulateClose(); t.mock.timers.tick(100000);
-  assert.equal(s.clients.length, 2, "budget of 1 attempt honoured");
-  assert.ok(s.events.some((e) => e.err && e.err.type === "stop_listen"));
-});

package/test/integration/package.test.js

@@ -1,116 +0,0 @@
-"use strict";
-/** Package-surface tests. Third-party modules are stubbed (see stub-modules.js) so these are MOCKED loads. */
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const path = require("path");
-const os = require("os");
-const fs = require("fs");
-const { builtinModules } = require("module");
-const { spawnSync } = require("child_process");
-const root = path.join(__dirname, "..", "..");
-const pkg = require(path.join(root, "package.json"));
-
-function walk(dir, out = []) {
-  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (["node_modules", "Fca_Database", "test", ".git"].includes(e.name)) continue;
-    const p = path.join(dir, e.name);
-    e.isDirectory() ? walk(p, out) : out.push(p);
-  }
-  return out;
-}
-
-test("package metadata: name, version, owner, entry points exist", () => {
-  assert.equal(pkg.name, "hridoy-ultimate");
-  assert.equal(pkg.version, "9.0.0");
-  assert.equal(pkg.author.name, "HR ID OY");
-  assert.ok(pkg.maintainers.some((m) => m.name === "HR ID OY"));
-  assert.ok(fs.existsSync(path.join(root, pkg.main)));
-  assert.ok(fs.existsSync(path.join(root, pkg.types)));
-  assert.ok(!Object.values(pkg.dependencies).some((v) => /^(git|github)/.test(v)), "no git dependencies in hard deps");
-});
-
-test("regression: every third-party module the source requires is declared", () => {
-  // 1.1.9 required request/tough-cookie/form-data/undici without declaring them.
-  const declared = new Set([...Object.keys(pkg.dependencies), ...Object.keys(pkg.optionalDependencies || {})]);
-  const builtins = new Set(builtinModules.flatMap((m) => [m, "node:" + m]));
-  const re = /require\(\s*["']([^"'./][^"']*)["']\s*\)|^\s*(?:import|export)[^;\n]*?\sfrom\s+["']([^"'./][^"']*)["']|\bimport\(\s*["']([^"'./][^"']*)["']\s*\)/gm;
-  const missing = new Map();
-  for (const f of walk(root).filter((p) => /\.(js|cjs|mjs)$/.test(p))) {
-    if (f.includes(`${path.sep}vendor${path.sep}`)) continue; // bundled third-party build, checked separately below
-    const src = fs.readFileSync(f, "utf8");
-    for (const m of src.matchAll(re)) {
-      let name = m[1] || m[2] || m[3];
-      if (builtins.has(name)) continue;
-      name = name.startsWith("@") ? name.split("/").slice(0, 2).join("/") : name.split("/")[0];
-      if (builtins.has(name) || declared.has(name)) continue;
-      missing.set(name, path.relative(root, f));
-    }
-  }
-  assert.deepEqual([...missing], [], "undeclared modules: " + JSON.stringify([...missing]));
-});
-
-test("vendored E2EE bundle: its external requires are declared too", () => {
-  const f = path.join(root, "src/api/socket/e2ee/vendor/fme/dist/index.cjs");
-  const declared = new Set([...Object.keys(pkg.dependencies), ...Object.keys(pkg.optionalDependencies || {})]);
-  const names = new Set([...fs.readFileSync(f, "utf8").matchAll(/require\("([^".][^"]*)"\)/g)].map((m) => m[1]).filter((n) => !n.startsWith("node:") && !builtinModules.includes(n)));
-  for (const n of names) assert.ok(declared.has(n), `${n} used by vendor bundle but undeclared`);
-});
-
-test("only the pinned messagix binaries ship, native stays opt-in, no default third-party credential host", () => {
-  const crypto = require("crypto");
-  const files = walk(root);
-  const bin = files.filter((p) => /\.(so|dll|dylib|node|exe)$/.test(p)).map((p) => path.relative(root, p).split(path.sep).join("/")).sort();
-  assert.deepEqual(bin, [
-    "src/api/socket/e2ee/native/build/messagix.dll",
-    "src/api/socket/e2ee/native/build/messagix.so"
-  ]);
-  const sha = (f) => crypto.createHash("sha256").update(fs.readFileSync(path.join(root, f))).digest("hex");
-  assert.equal(sha(bin[1]), "6249f50cc23de0b11a710266a2323c306d44cf46530880e58e0cd1cf4b5bf8d9");
-  assert.equal(sha(bin[0]), "f8597ba86c90c39cec19b660e75eba59f2022678eb20866b740cfa321036885e");
-  const e2ee = fs.readFileSync(path.join(root, "src/api/socket/e2ee/index.js"), "utf8");
-  assert.match(e2ee, /process\.env\.FCA_E2EE_NATIVE === "1" && _nativeLibAvailable\(\)/, "native engine must stay opt-in");
-  const hits = files.filter((p) => /\.(js|cjs|mjs|json)$/.test(p) && fs.readFileSync(p, "utf8").includes("minhdong.site"));
-  assert.deepEqual(hits.map((p) => path.relative(root, p)), []);
-  const cfg = fs.readFileSync(path.join(root, "module/config.js"), "utf8");
-  assert.match(cfg, /apiServer:\s*""/);
-  assert.match(cfg, /autoUpdate:\s*false/);
-  assert.match(cfg, /autoLogin:\s*false/);
-});
-
-test("every JS file in the package parses", () => {
-  const r = spawnSync(process.execPath, [path.join(root, "scripts/syntax-check.js")], { encoding: "utf8" });
-  assert.equal(r.status, 0, r.stdout + r.stderr);
-});
-
-test("[mocked] package loads with consistent exports", () => {
-  const stubs = require("../helpers/stub-modules");
-  stubs.install();
-  process.chdir(fs.mkdtempSync(path.join(os.tmpdir(), "hridoy-pkg-")));
-  const m = require(root);
-  assert.equal(typeof m.login, "function");
-  assert.equal(m.default, m.login);
-  const expected = ["login", "default", "createFcaClient", "MessengerBot", "createMessengerBot", "MessengerContext",
-    "attachThreadInfoRealtimeSync", "applyThreadInfoRealtimeEvent", "CommandHumanizer", "createCommandHumanizer",
-    "createHumanizerMiddleware", "humanizer", "TypingIndicator", "createTypingIndicator", "typingIndicator"];
-  assert.deepEqual(Object.keys(m).sort(), expected.sort(), "export surface changed: update README + this list");
-  for (const k of expected) assert.notEqual(m[k], undefined, `${k} is undefined`);
-});
-
-test("[mocked] login with empty options reports an error via callback and never throws", async () => {
-  const stubs = require("../helpers/stub-modules");
-  stubs.install();
-  process.chdir(fs.mkdtempSync(path.join(os.tmpdir(), "hridoy-login-")));
-  const m = require(root);
-  const rejections = [];
-  const onRej = (e) => rejections.push(e);
-  process.on("unhandledRejection", onRej);
-  const result = await new Promise((resolve) => {
-    const t = setTimeout(() => resolve({ timeout: true }), 5000);
-    m.login({}, {}, (err, api) => { clearTimeout(t); resolve({ err, api }); });
-  });
-  process.removeListener("unhandledRejection", onRej);
-  assert.ok(!result.timeout, "callback was invoked");
-  assert.ok(result.err, "error delivered");
-  assert.equal(result.api, undefined);
-  assert.deepEqual(rejections, []);
-});

package/test/integration/typing-wiring.test.js

@@ -1,71 +0,0 @@
-"use strict";
-/**
- * MOCKED integration: the typing indicator is wired into the real listenMqtt factory through the
- * shared ctx._middleware (also used by listenE2EE) and is torn down by stopListening().
- */
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const path = require("path");
-const os = require("os");
-const fs = require("fs");
-const root = process.env.HRIDOY_TEST_ROOT || path.join(__dirname, "..", "..");
-const stubs = require("../helpers/stub-modules");
-stubs.install();
-process.chdir(fs.mkdtempSync(path.join(os.tmpdir(), "hridoy-typing-")));
-
-function build({ withTyping = true, globalOptions = {} } = {}) {
-  stubs.purge(root);
-  stubs.FakeMqttClient.instances.length = 0;
-  const { TypingIndicator } = require(path.join(root, "src/utils/typingIndicator"));
-  const sent = [];
-  const api = {
-    getCookies: () => "c_user=1; xs=abc",
-    refreshFb_dtsg: () => Promise.resolve(),
-    sendTypingIndicator: (tid, state) => { sent.push([tid, state]); return Promise.resolve(); }
-  };
-  const ctx = {
-    userID: "100000000000001", clientId: "abcd1234", loggedIn: true, firstListen: true, lastSeqId: 42,
-    globalOptions: Object.assign({ autoReconnect: true, emitReady: true, userAgent: "UA" }, globalOptions),
-    tasks: new Map(), _mqttOpt: {}
-  };
-  if (withTyping) ctx._typing = new TypingIndicator(api, ctx, undefined);
-  const defaultFuncs = { get: () => Promise.resolve({ data: "" }), post: () => Promise.reject(new Error("network down (test)")) };
-  const factory = require(path.join(root, "src/api/socket/listenMqtt.js"));
-  const listen = factory(defaultFuncs, api, ctx);
-  const events = [];
-  const emitter = listen((err, msg) => events.push({ err, msg }));
-  return { ctx, api, sent, events, emitter };
-}
-
-const stopAndWait = (s) => new Promise((r) => s.emitter.stopListening(r));
-const msg = (over) => Object.assign({ type: "message", threadID: "t9", senderID: "42", body: "/ping", isGroup: false }, over);
-
-test("[mocked] typing middleware is installed by default and shows typing for a command without delaying delivery", async () => {
-  const s = build();
-  assert.ok(s.ctx._middleware.list().includes("typing"));
-  let delivered = null;
-  s.ctx._middleware.process(msg(), (err, ev) => { delivered = ev; });
-  assert.ok(delivered && delivered.body === "/ping", "event delivered synchronously");
-  assert.deepEqual(s.sent, [["t9", true]]);
-  await stopAndWait(s);
-});
-
-test("[mocked] plain chat does not trigger typing, and stopListening clears pending typing timers", async () => {
-  const s = build();
-  s.ctx._middleware.process(msg({ body: "hello everyone" }), () => {});
-  assert.deepEqual(s.sent, []);
-  s.ctx._middleware.process(msg(), () => {});
-  assert.equal(s.ctx._typing.isTyping("t9"), true);
-  await stopAndWait(s);
-  assert.equal(s.ctx._typing.isTyping("t9"), false, "stopListening tears typing down");
-});
-
-test("[mocked] typing middleware is NOT installed when the humanizer owns typing, or when no controller exists", async () => {
-  const hz = build({ globalOptions: { humanize: true } });
-  assert.ok(!hz.ctx._middleware.list().includes("typing"));
-  assert.ok(hz.ctx._middleware.list().includes("humanizer"));
-  await stopAndWait(hz);
-  const none = build({ withTyping: false });
-  assert.ok(!none.ctx._middleware.list().includes("typing"));
-  await stopAndWait(none);
-});

package/test/unit/fingerprint.test.js

@@ -1,19 +0,0 @@
-"use strict";
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const path = require("path");
-const root = process.env.HRIDOY_TEST_ROOT || path.join(__dirname, "..", "..");
-const fp = require(path.join(root, "src/utils/fingerprint"));
-
-test("fingerprint: UA is the reduced Chrome/<major>.0.0.0 form and the full build only appears in client hints", () => {
-  const ua = fp.getDefaultUserAgent();
-  const m = ua.match(/Chrome\/(\d+)\.(\d+)\.(\d+)\.(\d+)/);
-  assert.ok(m, ua);
-  assert.deepEqual([m[2], m[3], m[4]], ["0", "0", "0"], "UA must not leak the full build");
-  const { version, major } = fp.getFingerprint();
-  assert.equal(String(major), m[1]);
-  const h = fp.clientHintsFromUA(ua);
-  assert.ok(h["sec-ch-ua-full-version-list"].includes(`"Google Chrome";v="${version}"`));
-  assert.ok(h["sec-ch-ua"].includes(`"Google Chrome";v="${major}"`));
-  assert.ok(major >= 149, "pool must not fall back to years-old Chrome builds");
-});

package/test/unit/humanizer.test.js

@@ -1,32 +0,0 @@
-"use strict";
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const path = require("path");
-const root = process.env.HRIDOY_TEST_ROOT || path.join(__dirname, "..", "..");
-const { CommandHumanizer } = require(path.join(root, "src/utils/humanizer"));
-
-test("humanizer: first command accepted with a bounded delay, burst inside cooldown dropped", (t) => {
-  t.mock.timers.enable({ apis: ["Date"], now: 1_000_000 });
-  const h = new CommandHumanizer({ reactDelayMs: [2000, 3000], cooldownMs: 5500 });
-  const ev = { body: "/help", threadID: "t1" };
-  const first = h.shouldProcess(ev);
-  assert.equal(first.ok, true);
-  assert.ok(first.delayMs >= 2000 && first.delayMs <= 3000, `delay ${first.delayMs}`);
-  t.mock.timers.tick(100);
-  assert.equal(h.shouldProcess(ev).ok, false, "burst command dropped");
-  t.mock.timers.tick(6000);
-  assert.equal(h.shouldProcess(ev).ok, true, "accepted again after cooldown/reset");
-});
-
-test("humanizer: non-command messages pass untouched; per-thread isolation", (t) => {
-  t.mock.timers.enable({ apis: ["Date"], now: 5_000_000 });
-  const h = new CommandHumanizer({});
-  assert.equal(h.isCommand({ body: "hello", threadID: "a" }), false);
-  assert.equal(h.shouldProcess({ body: "/x", threadID: "a" }).ok, true);
-  assert.equal(h.shouldProcess({ body: "/x", threadID: "b" }).ok, true, "other thread unaffected");
-});
-
-test("humanizer: enabled:false never delays or drops", () => {
-  const h = new CommandHumanizer({ enabled: false });
-  for (let i = 0; i < 50; i++) assert.deepEqual(h.shouldProcess({ body: "/x", threadID: "a" }), { ok: true, delayMs: 0 });
-});

package/test/unit/lifecycle.test.js

@@ -1,92 +0,0 @@
-"use strict";
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const EventEmitter = require("events");
-const path = require("path");
-const root = process.env.HRIDOY_TEST_ROOT || path.join(__dirname, "..", "..");
-const L = require(path.join(root, "src/api/socket/core/lifecycle"));
-
-test("computeBackoff grows exponentially, is bounded and never negative", () => {
-  const rand = () => 0.5; // zero jitter offset
-  const seq = [0, 1, 2, 3, 4, 5, 6, 7, 8, 20, 1000].map(a => L.computeBackoff(a, { baseMs: 1000, maxMs: 60000, jitter: 0.3, random: rand }));
-  assert.deepEqual(seq.slice(0, 7), [1000, 2000, 4000, 8000, 16000, 32000, 60000]);
-  for (const v of seq) { assert.ok(v >= 0 && v <= 60000, `out of bounds: ${v}`); }
-  assert.equal(seq[seq.length - 1], 60000);
-});
-
-test("computeBackoff jitter stays within +/- jitter and clamps to max", () => {
-  const lo = L.computeBackoff(2, { baseMs: 1000, maxMs: 1e9, jitter: 0.3, random: () => 0 });
-  const hi = L.computeBackoff(2, { baseMs: 1000, maxMs: 1e9, jitter: 0.3, random: () => 1 });
-  assert.equal(lo, 2800); assert.equal(hi, 5200);
-  assert.equal(L.computeBackoff(10, { baseMs: 1000, maxMs: 5000, jitter: 1, random: () => 1 }), 5000);
-});
-
-test("computeBackoff tolerates garbage input", () => {
-  for (const bad of [undefined, null, NaN, -5, "x"]) {
-    const v = L.computeBackoff(bad, { baseMs: bad, maxMs: bad, jitter: bad });
-    assert.ok(Number.isFinite(v) && v >= 0);
-  }
-});
-
-test("scheduleReconnect: single timer, debounce, stop, exhaustion", async (t) => {
-  t.mock.timers.enable({ apis: ["setTimeout"] });
-  const ctx = { _mqttOpt: { reconnectDelayMs: 100, maxReconnectAttempts: 2, reconnectJitter: 0 } };
-  let fired = 0;
-  const fn = () => { fired++; };
-  assert.equal(L.scheduleReconnect(ctx, null, fn, "a"), "scheduled");
-  assert.equal(L.scheduleReconnect(ctx, null, fn, "b"), "debounced");
-  t.mock.timers.tick(100);
-  assert.equal(fired, 1);
-  assert.equal(ctx._reconnectTimer, null);
-  assert.equal(L.scheduleReconnect(ctx, null, fn, "c"), "scheduled"); // attempt 2 -> delay 200
-  t.mock.timers.tick(200);
-  assert.equal(fired, 2);
-  assert.equal(L.scheduleReconnect(ctx, null, fn, "d"), "exhausted");
-  ctx._stopped = true;
-  assert.equal(L.scheduleReconnect(ctx, null, fn, "e"), "stopped");
-});
-
-test("scheduleReconnect: a timer that fires after stop does nothing (race regression)", (t) => {
-  t.mock.timers.enable({ apis: ["setTimeout"] });
-  const ctx = { _mqttOpt: { reconnectDelayMs: 100, reconnectJitter: 0 } };
-  let fired = 0;
-  L.scheduleReconnect(ctx, null, () => fired++, "x");
-  ctx._stopped = true; // stop WITHOUT clearing the timer, e.g. a path that forgot to
-  t.mock.timers.tick(10000);
-  assert.equal(fired, 0);
-});
-
-test("maxReconnectAttempts: 0 means unlimited only when explicitly set", () => {
-  const ctx = { _reconnectAttempt: 9999, _mqttOpt: { maxReconnectAttempts: 0 } };
-  assert.equal(L.scheduleReconnect(ctx, null, () => {}, "u"), "scheduled");
-  clearTimeout(ctx._reconnectTimer);
-  const ctx2 = { _reconnectAttempt: 10, _mqttOpt: {} };
-  assert.equal(L.scheduleReconnect(ctx2, null, () => {}, "default"), "exhausted"); // default cap = 10
-});
-
-test("clearListenerTimers is idempotent and clears every owned timer", () => {
-  const ctx = {
-    _autoCycleTimer: setInterval(() => {}, 1e6), _heartbeatInterval: setInterval(() => {}, 1e6),
-    _sessionKeeperInterval: setTimeout(() => {}, 1e6), _rTimeout: setTimeout(() => {}, 1e6),
-    _reconnectTimer: setTimeout(() => {}, 1e6), _dtsgRefreshInterval: setInterval(() => {}, 1e6)
-  };
-  L.clearListenerTimers(ctx, false);
-  assert.equal(ctx._autoCycleTimer, null); assert.equal(ctx._heartbeatInterval, null);
-  assert.equal(ctx._sessionKeeperInterval, null); assert.equal(ctx._rTimeout, null); assert.equal(ctx._reconnectTimer, null);
-  assert.notEqual(ctx._dtsgRefreshInterval, null, "session timer kept unless includeSession");
-  L.clearListenerTimers(ctx, true);
-  assert.equal(ctx._dtsgRefreshInterval, null);
-  assert.doesNotThrow(() => L.clearListenerTimers(ctx, true));
-});
-
-test("detachClient: a late 'error' after detach must not throw", () => {
-  const c = new EventEmitter();
-  c.on("error", () => {});
-  L.detachClient(c);
-  assert.equal(c.listenerCount("message"), 0);
-  assert.doesNotThrow(() => c.emit("error", new Error("late socket error")));
-  assert.doesNotThrow(() => L.detachClient(null));
-  // contrast: plain removeAllListeners (the old behaviour) DOES throw
-  const d = new EventEmitter(); d.removeAllListeners();
-  assert.throws(() => d.emit("error", new Error("boom")));
-});

package/test/unit/parsers.test.js

@@ -1,43 +0,0 @@
-"use strict";
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const path = require("path");
-const root = process.env.HRIDOY_TEST_ROOT || path.join(__dirname, "..", "..");
-const { extractDtsg } = require(path.join(root, "src/utils/loginParser/extractDtsg"));
-const fp = require(path.join(root, "src/utils/fingerprint"));
-
-test("extractDtsg handles each supported markup shape", () => {
-  const cases = [
-    ['<script>["DTSGInitialData",[],{"token":"TOK_A"}]</script>', "TOK_A"],
-    ['x["DTSGInitData",[],{"token":"TOK_B","async_get_token":"zz"}]', "TOK_B"],
-    ['{"dtsg":{"token":"TOK_C"}}', "TOK_C"],
-    ['{"async_get_token":"TOK_D"}', "TOK_D"],
-    ['<input name="fb_dtsg" value="TOK_E">', "TOK_E"]
-  ];
-  for (const [html, want] of cases) assert.equal(extractDtsg(html).fb_dtsg, want, html);
-});
-
-test("extractDtsg: jazoest forms, empty and non-string input", () => {
-  assert.equal(extractDtsg('<input name="jazoest" value="2987">').jazoest, "2987");
-  assert.equal(extractDtsg("a?jazoest=2123&b").jazoest, "2123");
-  assert.deepEqual(extractDtsg(""), { fb_dtsg: null, jazoest: null });
-  assert.deepEqual(extractDtsg(null), { fb_dtsg: null, jazoest: null });
-  assert.deepEqual(extractDtsg("<html>nothing here</html>"), { fb_dtsg: null, jazoest: null });
-});
-
-test("fingerprint: default UA and client hints are mutually consistent", () => {
-  const ua = fp.getDefaultUserAgent();
-  assert.match(ua, /^Mozilla\/5\.0 /);
-  const h = fp.clientHintsFromUA(ua);
-  assert.equal(h["sec-ch-ua-mobile"], /Mobile|Android|iPhone/.test(ua) ? "?1" : "?0");
-  const m = ua.match(/Chrome\/(\d+)/);
-  if (m) assert.ok(h["sec-ch-ua"].includes(`v="${m[1]}"`), "hint major must match UA major");
-});
-
-test("fingerprint: Android UA yields mobile Android hints (no desktop contradiction)", () => {
-  const ua = "Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Mobile Safari/537.36";
-  const h = fp.clientHintsFromUA(ua);
-  assert.equal(h["sec-ch-ua-mobile"], "?1");
-  assert.equal(h["sec-ch-ua-platform"], '"Android"');
-  assert.equal(h["sec-ch-ua-arch"], undefined);
-});