mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
259 lines
8.3 KiB
TypeScript
259 lines
8.3 KiB
TypeScript
import * as fs from "node:fs";
|
|
import * as os from "node:os";
|
|
import * as path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
import { PyFloat, pyTypeName } from "../src/pycompat.js";
|
|
import {
|
|
CACHE_PREFS,
|
|
checkValidOs,
|
|
configJson,
|
|
determineUaOs,
|
|
getEnvVars,
|
|
getTargetOs,
|
|
isDomainSet,
|
|
mergeInto,
|
|
pyJsonDumpsAscii,
|
|
setInto,
|
|
spoofsWindowDimensions,
|
|
utilsDeps,
|
|
validateConfig,
|
|
validateType,
|
|
} from "../src/utils.js";
|
|
|
|
const BUNDLE_EXE = path.join(
|
|
path.dirname(fileURLToPath(import.meta.url)),
|
|
"fixtures",
|
|
"launch",
|
|
"bundle",
|
|
"camoufox-bin",
|
|
);
|
|
|
|
const WINDOWS_UA =
|
|
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0";
|
|
const MAC_UA =
|
|
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0";
|
|
const LINUX_UA =
|
|
"Mozilla/5.0 (X11; Linux x86_64; rv:135.0) Gecko/20100101 Firefox/135.0";
|
|
|
|
describe("determineUaOs", () => {
|
|
it("maps each supported UA to its short OS name", () => {
|
|
expect(determineUaOs(WINDOWS_UA)).toBe("win");
|
|
expect(determineUaOs(MAC_UA)).toBe("mac");
|
|
expect(determineUaOs(LINUX_UA)).toBe("lin");
|
|
});
|
|
|
|
it("falls back to lin for an unparseable UA, as the Python twin does", () => {
|
|
// Python's ua_parser answers "Other" rather than nothing, so its `raise`
|
|
// never fires. Throwing here instead would make
|
|
// `config: {"navigator.userAgent": ...}` launch under one launcher and
|
|
// hard-error under the other.
|
|
expect(determineUaOs("X")).toBe("lin");
|
|
expect(determineUaOs("")).toBe("lin");
|
|
});
|
|
});
|
|
|
|
describe("getTargetOs", () => {
|
|
it("derives the OS from the config's user agent", () => {
|
|
expect(getTargetOs({ "navigator.userAgent": WINDOWS_UA })).toBe("win");
|
|
});
|
|
});
|
|
|
|
describe("checkValidOs", () => {
|
|
it("accepts the supported OS names, individually and as a list", () => {
|
|
expect(() => checkValidOs("windows")).not.toThrow();
|
|
expect(() => checkValidOs(["macos", "linux"])).not.toThrow();
|
|
});
|
|
|
|
it("rejects unsupported and non-lowercase names", () => {
|
|
expect(() => checkValidOs("Windows")).toThrow(/lowercase/);
|
|
expect(() => checkValidOs("solaris")).toThrow(/does not support/);
|
|
});
|
|
});
|
|
|
|
describe("validateType", () => {
|
|
it("matches properties.json type names to JS values", () => {
|
|
expect(validateType("x", "str")).toBe(true);
|
|
expect(validateType(1, "str")).toBe(false);
|
|
expect(validateType(1, "int")).toBe(true);
|
|
expect(validateType(1.5, "int")).toBe(false);
|
|
expect(validateType(-1, "uint")).toBe(false);
|
|
expect(validateType(1.5, "double")).toBe(true);
|
|
expect(validateType(true, "bool")).toBe(true);
|
|
expect(validateType([], "array")).toBe(true);
|
|
expect(validateType({}, "dict")).toBe(true);
|
|
expect(validateType([], "dict")).toBe(false);
|
|
expect(validateType("x", "unknown-type")).toBe(false);
|
|
// Python's bool is an int, so it passes the numeric checks there too.
|
|
expect(validateType(true, "uint")).toBe(true);
|
|
// An integral Python float passes int/uint (float.is_integer()).
|
|
expect(validateType(new PyFloat(2), "uint")).toBe(true);
|
|
expect(validateType(new PyFloat(2), "str")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("isDomainSet", () => {
|
|
it("matches exact keys and dotted/colon prefixes", () => {
|
|
const config = { "navigator.platform": "Win32", "locale:region": "US" };
|
|
expect(isDomainSet(config, "navigator.platform")).toBe(true);
|
|
expect(isDomainSet(config, "navigator.")).toBe(true);
|
|
expect(isDomainSet(config, "locale:")).toBe(true);
|
|
expect(isDomainSet(config, "screen.")).toBe(false);
|
|
expect(isDomainSet(config, "timezone")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("mergeInto / setInto", () => {
|
|
it("never overwrites an existing key", () => {
|
|
const target: Record<string, unknown> = { a: 1 };
|
|
mergeInto(target, { a: 2, b: 3 });
|
|
expect(target).toEqual({ a: 1, b: 3 });
|
|
|
|
setInto(target, "a", 9);
|
|
setInto(target, "c", 9);
|
|
expect(target).toEqual({ a: 1, b: 3, c: 9 });
|
|
});
|
|
});
|
|
|
|
describe("getEnvVars", () => {
|
|
it("chunks the config across CAMOU_CONFIG_<n> in index order", () => {
|
|
// A payload comfortably larger than the 32767-char POSIX chunk size.
|
|
const config = { "navigator.userAgent": "x".repeat(70_000) };
|
|
const env = getEnvVars(config, "win", BUNDLE_EXE);
|
|
|
|
const keys = Object.keys(env)
|
|
.filter((k) => k.startsWith("CAMOU_CONFIG_"))
|
|
.sort((a, b) => Number(a.split("_").pop()) - Number(b.split("_").pop()));
|
|
expect(keys.length).toBeGreaterThan(1);
|
|
expect(keys[0]).toBe("CAMOU_CONFIG_1");
|
|
|
|
const reassembled = keys.map((k) => env[k]).join("");
|
|
expect(JSON.parse(reassembled)).toEqual(config);
|
|
});
|
|
});
|
|
|
|
describe("spoofsWindowDimensions", () => {
|
|
it("reassembles chunks before looking for a window dimension key", () => {
|
|
const config = { "window.outerWidth": 1280 };
|
|
expect(
|
|
spoofsWindowDimensions({ env: getEnvVars(config, "win", BUNDLE_EXE) }),
|
|
).toBe(true);
|
|
});
|
|
|
|
it("is false when nothing spoofs a window dimension", () => {
|
|
expect(
|
|
spoofsWindowDimensions({
|
|
env: getEnvVars({ "screen.width": 1920 }, "win", BUNDLE_EXE),
|
|
}),
|
|
).toBe(false);
|
|
expect(spoofsWindowDimensions({})).toBe(false);
|
|
});
|
|
|
|
it("finds a key that straddles a chunk boundary", () => {
|
|
// Pad so "window.outerHeight" is split across two CAMOU_CONFIG_<n> vars.
|
|
const config = {
|
|
pad: "x".repeat(32_750),
|
|
"window.outerHeight": 720,
|
|
};
|
|
const env = getEnvVars(config, "win", BUNDLE_EXE);
|
|
expect(
|
|
Object.keys(env).filter((k) => k.startsWith("CAMOU_CONFIG_")).length,
|
|
).toBeGreaterThan(1);
|
|
expect(spoofsWindowDimensions({ env })).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("Python-compatible serialisation", () => {
|
|
it("chunks by code point, as Python slices a str", () => {
|
|
// 32767 emoji: one chunk in Python (code points), two UTF-16 halves each.
|
|
const config = { v: "\u{1F600}".repeat(40_000) };
|
|
const env = getEnvVars(config, "win", BUNDLE_EXE);
|
|
const chunks = Object.keys(env).filter((k) =>
|
|
k.startsWith("CAMOU_CONFIG_"),
|
|
);
|
|
const blob = JSON.stringify(config);
|
|
expect(chunks).toHaveLength(Math.ceil(Array.from(blob).length / 32767));
|
|
expect(Array.from(String(env.CAMOU_CONFIG_1))).toHaveLength(32767);
|
|
});
|
|
|
|
it("writes a PyFloat with its .0 and a bigint exactly", () => {
|
|
expect(configJson({ a: new PyFloat(2), b: 2, c: 1.5, d: 2n ** 64n })).toBe(
|
|
'{"a":2.0,"b":2,"c":1.5,"d":18446744073709551616}',
|
|
);
|
|
});
|
|
|
|
it("names types the way Python does in its errors", () => {
|
|
expect(pyTypeName(1)).toBe("int");
|
|
expect(pyTypeName(1.5)).toBe("float");
|
|
expect(pyTypeName(new PyFloat(1))).toBe("float");
|
|
expect(pyTypeName(true)).toBe("bool");
|
|
expect(pyTypeName(null)).toBe("NoneType");
|
|
expect(pyTypeName([])).toBe("list");
|
|
expect(pyTypeName({})).toBe("dict");
|
|
});
|
|
|
|
it("json.dumps(ensure_ascii=True) for the prefs", () => {
|
|
expect(pyJsonDumpsAscii({ a: "é\u007f", b: 1e-5, c: [true, null] })).toBe(
|
|
'{"a":"\\u00e9\\u007f","b":1e-05,"c":[true,null]}',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("validateConfig with removed keys (#835)", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
function browserWith(entries: object[]): string {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "camoufox-props-"));
|
|
fs.writeFileSync(
|
|
path.join(dir, "properties.json"),
|
|
JSON.stringify(entries),
|
|
);
|
|
return path.join(dir, "camoufox-bin");
|
|
}
|
|
|
|
it("skips a removed key and names the release that removed it", () => {
|
|
const printed: string[] = [];
|
|
vi.spyOn(utilsDeps, "print").mockImplementation((msg: string) => {
|
|
printed.push(msg);
|
|
});
|
|
const binary = browserWith([
|
|
{ property: "navigator.userAgent", type: "str" },
|
|
{
|
|
property: "navigator.appCodeName",
|
|
type: "str",
|
|
removed: "156.0.1-beta.32",
|
|
},
|
|
]);
|
|
validateConfig(
|
|
{ "navigator.appCodeName": "Mozilla", "navigator.userAgent": "x" },
|
|
binary,
|
|
);
|
|
expect(printed.join("\n")).toContain(
|
|
"navigator.appCodeName: removed in 156.0.1-beta.32",
|
|
);
|
|
});
|
|
|
|
it("does not type-check a removed key", () => {
|
|
vi.spyOn(utilsDeps, "print").mockImplementation(() => undefined);
|
|
const binary = browserWith([
|
|
{
|
|
property: "navigator.languages",
|
|
type: "array",
|
|
removed: "156.0.1-beta.32",
|
|
},
|
|
]);
|
|
expect(() =>
|
|
validateConfig({ "navigator.languages": "not-an-array" }, binary),
|
|
).not.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("CACHE_PREFS", () => {
|
|
it("leaves history length at stock", () => {
|
|
// history.length is page-readable; stock Firefox keeps 50 entries.
|
|
expect(CACHE_PREFS).not.toHaveProperty([
|
|
"browser.sessionhistory.max_entries",
|
|
]);
|
|
});
|
|
});
|