@vangbanlanhat/fca-unofficial 1.4.2

package/test/unit/actions/actions.basic.test.js

@@ -0,0 +1,116 @@
+"use strict";
+
+describe("action behavior basics", function () {
+  test("getCurrentUserID returns ctx.userID", function () {
+    var factory = require("../../../src/actions/getCurrentUserID");
+    var fn = factory({}, {}, { userID: "123456" });
+
+    expect(fn()).toBe("123456");
+  });
+
+  test("getCurrentUserID supports callback and await style", async function () {
+    var factory = require("../../../src/actions/getCurrentUserID");
+    var fn = factory({}, {}, { userID: "123456" });
+
+    var cbValue;
+    fn(function (err, value) {
+      expect(err).toBeNull();
+      cbValue = value;
+    });
+
+    expect(cbValue).toBe("123456");
+    expect(await fn()).toBe("123456");
+  });
+
+  test("threadColors exposes known palette keys", function () {
+    var factory = require("../../../src/actions/threadColors");
+    var colors = factory({}, {}, {});
+
+    expect(colors).toHaveProperty("DefaultBlue");
+    expect(colors).toHaveProperty("HotPink");
+    expect(colors).toHaveProperty("MessengerBlue");
+    expect(typeof colors.DefaultBlue).toBe("string");
+  });
+
+  test("addExternalModule injects dynamic API functions", function () {
+    var factory = require("../../../src/actions/addExternalModule");
+    var api = {};
+    var defaultFuncs = {};
+    var ctx = { userID: "42" };
+
+    var addExternalModule = factory(defaultFuncs, api, ctx);
+
+    addExternalModule({
+      ping: function (_defaultFuncs, _api, _ctx) {
+        return function () {
+          return _ctx.userID;
+        };
+      }
+    });
+
+    expect(typeof api.ping).toBe("function");
+    expect(api.ping()).toBe("42");
+  });
+
+  test("addExternalModule validates input types", function () {
+    var factory = require("../../../src/actions/addExternalModule");
+    var api = {};
+    var addExternalModule = factory({}, api, {});
+
+    expect(function () {
+      addExternalModule("invalid");
+    }).toThrow("moduleObj must be an object");
+
+    expect(function () {
+      addExternalModule({ bad: 123 });
+    }).toThrow('Item "bad" in moduleObj must be a function');
+  });
+
+  test("addExternalModule supports callback", function () {
+    var factory = require("../../../src/actions/addExternalModule");
+    var api = {};
+    var defaultFuncs = {};
+    var ctx = { userID: "42" };
+    var addExternalModule = factory(defaultFuncs, api, ctx);
+
+    var callbackResult;
+    var result = addExternalModule({
+      ping: function (_defaultFuncs, _api, _ctx) {
+        return function () {
+          return _ctx.userID;
+        };
+      }
+    }, function (err, ok) {
+      expect(err).toBeNull();
+      callbackResult = ok;
+    });
+
+    expect(result).toBe(true);
+    expect(callbackResult).toBe(true);
+    expect(api.ping()).toBe("42");
+  });
+
+  test("getRegion and getEmojiUrl support callback", function () {
+    var getRegionFactory = require("../../../src/actions/getRegion");
+    var getEmojiUrlFactory = require("../../../src/actions/getEmojiUrl");
+
+    var getRegion = getRegionFactory({}, {}, { region: "PRN" });
+    var getEmojiUrl = getEmojiUrlFactory({}, {}, {});
+
+    var regionValue;
+    getRegion(function (err, value) {
+      expect(err).toBeNull();
+      regionValue = value;
+    });
+
+    var emojiValue;
+    getEmojiUrl("😀", 64, function (err, value) {
+      expect(err).toBeNull();
+      emojiValue = value;
+    });
+
+    expect(regionValue).toBe("PRN");
+    expect(typeof emojiValue).toBe("string");
+    expect(emojiValue).toContain("emoji.php");
+  });
+});

package/test/unit/actions/actions.registry.test.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var fs = require("fs");
+var path = require("path");
+
+var actions = require("../../../src/actions");
+
+describe("actions registry", function () {
+  test("exports only file-backed action factories", function () {
+    var actionsDir = path.join(__dirname, "../../../src/actions");
+    var files = fs
+      .readdirSync(actionsDir)
+      .filter(function (name) {
+        return name.endsWith(".js") && name !== "index.js";
+      })
+      .map(function (name) {
+        return name.replace(/\.js$/, "");
+      })
+      .sort();
+
+    var exported = Object.keys(actions).sort();
+
+    exported.forEach(function (name) {
+      expect(files.includes(name)).toBe(true);
+      expect(typeof actions[name]).toBe("function");
+    });
+
+    expect(exported.length).toBeGreaterThan(0);
+  });
+
+  test("every exported action is a factory function", function () {
+    Object.keys(actions).forEach(function (name) {
+      expect(typeof actions[name]).toBe("function");
+    });
+  });
+});

package/test/unit/index/index.test.js

@@ -0,0 +1,109 @@
+"use strict";
+
+describe("src/index", function () {
+  test("exports login function and wires actions when using appState", function () {
+    return new Promise(function (resolve, reject) {
+      jest.isolateModules(function () {
+        var actionFactory = jest.fn(function () {
+          return function () {
+            return "ok";
+          };
+        });
+        var listenFactory = jest.fn(function () {
+          return function () {
+            return "listening";
+          };
+        });
+
+        jest.doMock("../../../src/actions", function () {
+          return {
+            foo: actionFactory,
+            listenMqtt: listenFactory
+          };
+        });
+
+        jest.doMock("npmlog", function () {
+          return {
+            maxRecordSize: 0,
+            level: "info",
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn()
+          };
+        });
+
+        var jar = {
+          setCookie: jest.fn(),
+          getCookies: jest.fn(function () {
+            return [
+              {
+                cookieString: function () {
+                  return "c_user=123";
+                }
+              }
+            ];
+          })
+        };
+
+        jest.doMock("../../../src/utils", function () {
+          return {
+            getType: function (obj) {
+              return Object.prototype.toString.call(obj).slice(8, -1);
+            },
+            setProxy: jest.fn(),
+            getJar: function () {
+              return jar;
+            },
+            get: jest.fn(function () {
+              return Promise.resolve({ body: "<html></html>" });
+            }),
+            saveCookies: function () {
+              return function (res) {
+                return res;
+              };
+            },
+            makeDefaults: jest.fn(function () {
+              return {};
+            }),
+            getAppState: jest.fn(function () {
+              return [];
+            })
+          };
+        });
+
+        var login = require("../../../src/index");
+        expect(typeof login).toBe("function");
+
+        login(
+          {
+            appState: [
+              {
+                key: "c_user",
+                value: "123",
+                domain: ".facebook.com",
+                path: "/",
+                expires: Date.now() + 1000
+              }
+            ],
+            email: "",
+            password: ""
+          },
+          {},
+          function (err, api) {
+            try {
+              expect(err).toBeNull();
+              expect(typeof api.foo).toBe("function");
+              expect(typeof api.listenMqtt).toBe("function");
+              expect(api.listen).toBe(api.listenMqtt);
+              expect(actionFactory).toHaveBeenCalled();
+              expect(listenFactory).toHaveBeenCalled();
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          }
+        );
+      });
+    });
+  });
+});

package/test/unit/utils/base-parts/auth.test.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var auth = require("../../../../src/utils/base-parts/auth");
+var network = require("../../../../src/utils/base-parts/network");
+
+describe("auth utilities", function () {
+  test("formatCookie builds expected cookie string", function () {
+    var c = auth.formatCookie(["c_user", "123", "", "/"], "facebook");
+    expect(c).toBe("c_user=123; Path=/; Domain=facebook.com");
+  });
+
+  test("makeDefaults merges protocol defaults into get/post/postFormData", async function () {
+    var getSpy = jest.spyOn(network, "get").mockResolvedValue({ ok: true });
+    var postSpy = jest.spyOn(network, "post").mockResolvedValue({ ok: true });
+    var postFormSpy = jest
+      .spyOn(network, "postFormData")
+      .mockResolvedValue({ ok: true });
+
+    var html = '<input name="fb_dtsg" value="abc"> revision":123,';
+    var ctx = { globalOptions: { userAgent: "ua" } };
+
+    var defaults = auth.makeDefaults(html, "uid-1", ctx);
+
+    await defaults.get("https://x", "jar", { q: 1 });
+    await defaults.post("https://x", "jar", { p: 1 });
+    await defaults.postFormData("https://x", "jar", { f: 1 }, { k: 1 });
+
+    expect(getSpy).toHaveBeenCalled();
+    expect(postSpy).toHaveBeenCalled();
+    expect(postFormSpy).toHaveBeenCalled();
+
+    var getQs = getSpy.mock.calls[0][2];
+    var postForm = postSpy.mock.calls[0][2];
+
+    expect(getQs).toHaveProperty("__user", "uid-1");
+    expect(getQs).toHaveProperty("fb_dtsg", "abc");
+    expect(postForm).toHaveProperty("jazoest");
+  });
+
+  test("parseAndCheckLogin parses standard JSON response", async function () {
+    var ctx = { jar: { setCookie: jest.fn() } };
+    var fn = auth.parseAndCheckLogin(ctx, {});
+
+    var out = await fn({
+      statusCode: 200,
+      body: '{"ok":1}',
+      request: { method: "POST", headers: { "Content-Type": "application/json" } }
+    });
+
+    expect(out).toEqual({ ok: 1 });
+  });
+
+  test("parseAndCheckLogin throws for Not logged in marker", async function () {
+    var ctx = { jar: { setCookie: jest.fn() } };
+    var fn = auth.parseAndCheckLogin(ctx, {});
+
+    await expect(
+      fn({
+        statusCode: 200,
+        body: '{"error":1357001}',
+        request: { method: "POST", headers: { "Content-Type": "application/json" } }
+      })
+    ).rejects.toEqual({ error: "Not logged in." });
+  });
+
+  test("saveCookies writes facebook and messenger cookies", function () {
+    var setCookie = jest.fn();
+    var jar = { setCookie: setCookie };
+
+    auth.saveCookies(jar)({
+      headers: {
+        "set-cookie": ["a=b; domain=.facebook.com; Path=/"]
+      }
+    });
+
+    expect(setCookie).toHaveBeenCalled();
+    expect(setCookie.mock.calls[0][1]).toBe("https://www.facebook.com");
+    expect(setCookie.mock.calls[1][1]).toBe("https://www.messenger.com");
+  });
+
+  test("getAppState combines facebook and messenger cookie stores", function () {
+    var jar = {
+      getCookies: jest.fn(function (url) {
+        if (url === "https://www.facebook.com") return [1];
+        if (url === "https://facebook.com") return [2];
+        return [3];
+      })
+    };
+
+    expect(auth.getAppState(jar)).toEqual([1, 2, 3]);
+  });
+});

package/test/unit/utils/base-parts/formatters.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var fmt = require("../../../../src/utils/base-parts/formatters");
+var shareFixture = require("../../../data/shareAttach");
+
+describe("formatter utilities", function () {
+  test("formatID strips facebook prefixes", function () {
+    expect(fmt.formatID("fbid:12345")).toBe("12345");
+    expect(fmt.formatID("id.12345")).toBe("12345");
+    expect(fmt.formatID("12345")).toBe("12345");
+  });
+
+  test("formatProxyPresence returns null for incomplete payload", function () {
+    expect(fmt.formatProxyPresence({ lat: 1 }, "u1")).toBeNull();
+  });
+
+  test("formatProxyPresence and formatPresence normalize shape", function () {
+    expect(fmt.formatProxyPresence({ lat: 123, p: { x: 1 } }, "u1")).toEqual({
+      type: "presence",
+      timestamp: 123000,
+      userID: "u1",
+      statuses: { x: 1 }
+    });
+
+    expect(fmt.formatPresence({ la: 456, a: { y: 2 } }, "u2")).toEqual({
+      type: "presence",
+      timestamp: 456000,
+      userID: "u2",
+      statuses: { y: 2 }
+    });
+  });
+
+  test("formatDate renders GMT date string", function () {
+    var d = new Date(Date.UTC(2024, 0, 2, 3, 4, 5));
+    expect(fmt.formatDate(d)).toBe("Tue, 02 Jan 2024 03:04:05 GMT");
+  });
+
+  test("formatDeltaMessage parses share fixture", function () {
+    var out = fmt.formatDeltaMessage(shareFixture);
+
+    expect(out).toHaveProperty("type", "message");
+    expect(out).toHaveProperty("threadID");
+    expect(out).toHaveProperty("messageID");
+    expect(Array.isArray(out.attachments)).toBe(true);
+    expect(out.attachments.length).toBeGreaterThan(0);
+    expect(out.attachments[0]).toHaveProperty("type");
+  });
+
+  test("admin text message type mapping works", function () {
+    expect(fmt.getAdminTextMessageType("change_thread_theme")).toBe("log:thread-color");
+    expect(fmt.getAdminTextMessageType("other_type")).toBe("other_type");
+  });
+});

package/test/unit/utils/base-parts/identity.test.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var identity = require("../../../../src/utils/base-parts/identity");
+
+describe("identity utilities", function () {
+  test("generateThreadingID includes client id and expected envelope", function () {
+    var id = identity.generateThreadingID("clientabc");
+    expect(id).toMatch(/^<\d+:\d+-clientabc@mail\.projektitan\.com>$/);
+  });
+
+  test("generateOfflineThreadingID returns decimal numeric string", function () {
+    var id = identity.generateOfflineThreadingID();
+    expect(id).toMatch(/^\d+$/);
+  });
+
+  test("getGUID returns uuid-like id", function () {
+    var guid = identity.getGUID();
+    expect(guid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+  });
+
+  test("getSignatureID returns hex string", function () {
+    expect(identity.getSignatureID()).toMatch(/^[0-9a-f]+$/);
+  });
+
+  test("generateTimestampRelative returns hh:mm", function () {
+    expect(identity.generateTimestampRelative()).toMatch(/^\d{1,2}:\d{2}$/);
+  });
+
+  test("generatePresence returns encoded payload prefix E", function () {
+    var p = identity.generatePresence("12345");
+    expect(typeof p).toBe("string");
+    expect(p.startsWith("E")).toBe(true);
+    expect(p.length).toBeGreaterThan(20);
+  });
+
+  test("generateAccessiblityCookie returns URI-encoded JSON", function () {
+    var encoded = identity.generateAccessiblityCookie();
+    var decoded = JSON.parse(decodeURIComponent(encoded));
+    expect(decoded).toHaveProperty("sr");
+    expect(decoded).toHaveProperty("sr-ts");
+    expect(decoded).toHaveProperty("hcm-ts");
+  });
+});

package/test/unit/utils/base-parts/parsing.test.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var parsing = require("../../../../src/utils/base-parts/parsing");
+
+describe("parsing utilities", function () {
+  test("getFrom returns extracted token content", function () {
+    var html = "prefix [TOKEN]value123[/TOKEN] suffix";
+    expect(parsing.getFrom(html, "[TOKEN]", "[/TOKEN]")).toBe("value123");
+  });
+
+  test("getFrom returns empty when start token missing", function () {
+    expect(parsing.getFrom("abc", "<x>", "</x>")).toBe("");
+  });
+
+  test("getFrom throws when end token missing", function () {
+    expect(function () {
+      parsing.getFrom("<x>abc", "<x>", "</x>");
+    }).toThrow("Could not find endTime");
+  });
+
+  test("makeParsable strips for(;;) and merges concatenated objects", function () {
+    var raw = "for (;;);{\"a\":1}\r\n {\"b\":2}";
+    expect(parsing.makeParsable(raw)).toBe("[{\"a\":1},{\"b\":2}]");
+  });
+
+  test("arrToForm converts list into object", function () {
+    var out = parsing.arrToForm([
+      { name: "foo", val: "bar" },
+      { name: "count", val: 3 }
+    ]);
+    expect(out).toEqual({ foo: "bar", count: 3 });
+  });
+
+  test("decodeClientPayload decodes byte array JSON payload", function () {
+    var bytes = [123, 34, 97, 34, 58, 49, 125]; // {"a":1}
+    expect(parsing.decodeClientPayload(bytes)).toEqual({ a: 1 });
+  });
+});

package/test/unit/utils/base-parts/type.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var getType = require("../../../../src/utils/base-parts/type").getType;
+
+describe("type.getType", function () {
+  test("detects primitives and objects", function () {
+    expect(getType(null)).toBe("Null");
+    expect(getType(undefined)).toBe("Undefined");
+    expect(getType("x")).toBe("String");
+    expect(getType(1)).toBe("Number");
+    expect(getType({})).toBe("Object");
+    expect(getType([])).toBe("Array");
+    expect(getType(new Date())).toBe("Date");
+  });
+
+  test("detects function variants", async function () {
+    function fn() {}
+    async function afn() {}
+
+    expect(getType(fn)).toBe("Function");
+    expect(getType(afn)).toBe("AsyncFunction");
+  });
+});

package/test/unit/utils/base.test.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var base = require("../../../src/utils/base");
+
+describe("base exports", function () {
+  test("exposes core utility API surface", function () {
+    var expectedFunctions = [
+      "get",
+      "post",
+      "postFormData",
+      "setProxy",
+      "getJar",
+      "makeDefaults",
+      "parseAndCheckLogin",
+      "saveCookies",
+      "getAppState",
+      "getFrom",
+      "arrToForm",
+      "decodeClientPayload",
+      "generateThreadingID",
+      "generateOfflineThreadingID",
+      "getGUID",
+      "getSignatureID",
+      "generatePresence",
+      "formatMessage",
+      "formatDeltaMessage",
+      "formatThread",
+      "getType"
+    ];
+
+    expectedFunctions.forEach(function (name) {
+      expect(base).toHaveProperty(name);
+    });
+  });
+});