mirror of
https://github.com/zhom/donutbrowser.git
synced 2026-07-23 12:50:59 +02:00
zhom
601 lines
17 KiB
JavaScript
601 lines
17 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import { spawn, spawnSync } from "node:child_process";
|
|
import {
|
|
createReadStream,
|
|
createWriteStream,
|
|
existsSync,
|
|
statSync,
|
|
} from "node:fs";
|
|
import { chmod, mkdir, mkdtemp, readFile, rename, rm } from "node:fs/promises";
|
|
import http from "node:http";
|
|
import https from "node:https";
|
|
import net from "node:net";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { pipeline } from "node:stream/promises";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
const projectRoot = path.resolve(dirname, "..");
|
|
const webdriverRoot = path.resolve(
|
|
projectRoot,
|
|
"../tauri-cross-platform-webdriver",
|
|
);
|
|
const isWindows = process.platform === "win32";
|
|
const executableSuffix = isWindows ? ".exe" : "";
|
|
const appBinary = path.join(
|
|
projectRoot,
|
|
"src-tauri",
|
|
"target",
|
|
"debug",
|
|
`donutbrowser${executableSuffix}`,
|
|
);
|
|
const driverBinary = path.join(
|
|
webdriverRoot,
|
|
"target",
|
|
"debug",
|
|
`tauri-wd${executableSuffix}`,
|
|
);
|
|
|
|
const suiteFiles = {
|
|
smoke: ["smoke.test.mjs", "coverage.test.mjs"],
|
|
ui: ["ui.test.mjs"],
|
|
entities: ["entities.test.mjs"],
|
|
integrations: ["integrations.test.mjs"],
|
|
sync: ["sync.test.mjs"],
|
|
browser: ["browser.test.mjs"],
|
|
full: [
|
|
"coverage.test.mjs",
|
|
"smoke.test.mjs",
|
|
"ui.test.mjs",
|
|
"entities.test.mjs",
|
|
"integrations.test.mjs",
|
|
"sync.test.mjs",
|
|
"browser.test.mjs",
|
|
],
|
|
};
|
|
|
|
function parseArgs(argv) {
|
|
const options = {
|
|
suite: "full",
|
|
build: true,
|
|
keep: process.env.DONUT_E2E_KEEP_ARTIFACTS === "1",
|
|
verbose: process.env.DONUT_E2E_VERBOSE === "1",
|
|
};
|
|
for (const arg of argv) {
|
|
if (arg.startsWith("--suite=")) {
|
|
options.suite = arg.slice("--suite=".length);
|
|
} else if (arg === "--no-build") {
|
|
options.build = false;
|
|
} else if (arg === "--keep") {
|
|
options.keep = true;
|
|
} else if (arg === "--verbose") {
|
|
options.verbose = true;
|
|
} else {
|
|
throw new Error(`Unknown E2E option: ${arg}`);
|
|
}
|
|
}
|
|
if (!suiteFiles[options.suite]) {
|
|
throw new Error(
|
|
`Unknown suite ${options.suite}; expected ${Object.keys(suiteFiles).join(", ")}`,
|
|
);
|
|
}
|
|
return options;
|
|
}
|
|
|
|
function log(message) {
|
|
process.stdout.write(`[donut-e2e] ${message}\n`);
|
|
}
|
|
|
|
function run(command, args, cwd, env = process.env) {
|
|
log(`${command} ${args.join(" ")}`);
|
|
const result = spawnSync(command, args, { cwd, env, stdio: "inherit" });
|
|
if (result.error) {
|
|
throw result.error;
|
|
}
|
|
if (result.status !== 0) {
|
|
throw new Error(`${command} exited with status ${result.status}`);
|
|
}
|
|
}
|
|
|
|
async function freePort() {
|
|
return new Promise((resolve, reject) => {
|
|
const server = net.createServer();
|
|
server.unref();
|
|
server.once("error", reject);
|
|
server.listen(0, "127.0.0.1", () => {
|
|
const address = server.address();
|
|
server.close(() => resolve(address.port));
|
|
});
|
|
});
|
|
}
|
|
|
|
async function waitForUrl(url, timeoutMs, processRecord) {
|
|
const started = Date.now();
|
|
let lastError;
|
|
while (Date.now() - started < timeoutMs) {
|
|
if (processRecord?.process.exitCode !== null) {
|
|
throw new Error(
|
|
`${processRecord.name} exited early with ${processRecord.process.exitCode}; see ${processRecord.logPath}`,
|
|
);
|
|
}
|
|
try {
|
|
const response = await fetch(url, { signal: AbortSignal.timeout(1_000) });
|
|
if (response.ok) {
|
|
return;
|
|
}
|
|
lastError = new Error(`HTTP ${response.status}`);
|
|
} catch (error) {
|
|
lastError = error;
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
}
|
|
throw new Error(`Timed out waiting for ${url}: ${lastError}`);
|
|
}
|
|
|
|
function startProcess(name, command, args, { cwd, env, runRoot, verbose }) {
|
|
const logPath = path.join(runRoot, "logs", `${name}.log`);
|
|
const stream = createWriteStream(logPath, { flags: "a" });
|
|
const child = spawn(command, args, {
|
|
cwd,
|
|
env,
|
|
detached: !isWindows,
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
});
|
|
child.stdout.pipe(stream, { end: false });
|
|
child.stderr.pipe(stream, { end: false });
|
|
if (verbose) {
|
|
child.stdout.on("data", (chunk) =>
|
|
process.stdout.write(`[${name}] ${chunk}`),
|
|
);
|
|
child.stderr.on("data", (chunk) =>
|
|
process.stderr.write(`[${name}] ${chunk}`),
|
|
);
|
|
}
|
|
child.on("error", (error) => {
|
|
process.stderr.write(`[donut-e2e] ${name} process error: ${error}\n`);
|
|
});
|
|
return { name, process: child, stream, logPath };
|
|
}
|
|
|
|
async function stopProcess(record) {
|
|
if (!record || record.process.exitCode !== null) {
|
|
record?.stream.end();
|
|
return;
|
|
}
|
|
if (isWindows) {
|
|
spawnSync("taskkill", ["/PID", String(record.process.pid), "/T", "/F"], {
|
|
stdio: "ignore",
|
|
});
|
|
} else {
|
|
try {
|
|
process.kill(-record.process.pid, "SIGTERM");
|
|
} catch {
|
|
// The process group may already be gone.
|
|
}
|
|
}
|
|
await Promise.race([
|
|
new Promise((resolve) => record.process.once("exit", resolve)),
|
|
new Promise((resolve) => setTimeout(resolve, 5_000)),
|
|
]);
|
|
if (record.process.exitCode === null && !isWindows) {
|
|
try {
|
|
process.kill(-record.process.pid, "SIGKILL");
|
|
} catch {
|
|
// The process group may already be gone.
|
|
}
|
|
}
|
|
record.stream.end();
|
|
}
|
|
|
|
async function loadLocalToken() {
|
|
if (process.env.WAYFERN_TEST_TOKEN) {
|
|
return process.env.WAYFERN_TEST_TOKEN;
|
|
}
|
|
for (const file of [
|
|
path.join(projectRoot, ".env"),
|
|
path.resolve(projectRoot, "../wayfern-test/.env"),
|
|
]) {
|
|
try {
|
|
const content = await readFile(file, "utf8");
|
|
const match = content.match(
|
|
/^\s*(?:export\s+)?WAYFERN_TEST_TOKEN\s*=\s*(.+?)\s*$/m,
|
|
);
|
|
if (match) {
|
|
const raw = match[1].trim();
|
|
return raw.replace(/^(['"])(.*)\1$/, "$2");
|
|
}
|
|
} catch {
|
|
// A local token is only mandatory for the browser suite.
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function buildAll() {
|
|
if (!existsSync(webdriverRoot)) {
|
|
throw new Error(`Missing sibling webdriver repository: ${webdriverRoot}`);
|
|
}
|
|
run("pnpm", ["build"], projectRoot);
|
|
run("pnpm", ["copy-proxy-binary"], projectRoot);
|
|
run(
|
|
"cargo",
|
|
["build", "--features", "e2e", "--bin", "donutbrowser"],
|
|
path.join(projectRoot, "src-tauri"),
|
|
);
|
|
run(
|
|
"cargo",
|
|
["build", "--package", "tauri-cross-platform-webdriver"],
|
|
webdriverRoot,
|
|
);
|
|
}
|
|
|
|
function startFixtureServer(geoIpFixture) {
|
|
const server = http.createServer((request, response) => {
|
|
const url = new URL(request.url, "http://127.0.0.1");
|
|
if (url.pathname === "/health") {
|
|
response.writeHead(200, { "content-type": "text/plain" });
|
|
response.end("ok");
|
|
return;
|
|
}
|
|
if (url.pathname === "/api/echo") {
|
|
const chunks = [];
|
|
request.on("data", (chunk) => chunks.push(chunk));
|
|
request.on("end", () => {
|
|
response.writeHead(200, {
|
|
"content-type": "application/json",
|
|
"set-cookie": "donut_e2e=browser-ok; Path=/; SameSite=Lax",
|
|
});
|
|
response.end(
|
|
JSON.stringify({
|
|
method: request.method,
|
|
body: Buffer.concat(chunks).toString("utf8"),
|
|
userAgent: request.headers["user-agent"],
|
|
}),
|
|
);
|
|
});
|
|
return;
|
|
}
|
|
if (url.pathname.startsWith("/dns/")) {
|
|
response.writeHead(200, {
|
|
"content-type": "text/plain; charset=utf-8",
|
|
"cache-control": "no-store",
|
|
});
|
|
response.end("ads.e2e.invalid\ntracker.e2e.invalid\n");
|
|
return;
|
|
}
|
|
if (url.pathname === "/geoip.mmdb" && geoIpFixture) {
|
|
response.writeHead(200, {
|
|
"content-type": "application/octet-stream",
|
|
"content-length": String(statSync(geoIpFixture).size),
|
|
});
|
|
createReadStream(geoIpFixture).pipe(response);
|
|
return;
|
|
}
|
|
response.writeHead(200, {
|
|
"content-type": "text/html; charset=utf-8",
|
|
"cache-control": "no-store",
|
|
});
|
|
response.end(`<!doctype html>
|
|
<html>
|
|
<head><title>Donut E2E Browser Fixture</title></head>
|
|
<body>
|
|
<h1 id="fixture-title">Donut E2E Browser Fixture</h1>
|
|
<p id="path">${url.pathname}</p>
|
|
<button id="fixture-button" onclick="this.dataset.clicked='yes'; this.textContent='Clicked'">Click fixture</button>
|
|
<script>window.__fixtureReady = true;</script>
|
|
</body>
|
|
</html>`);
|
|
});
|
|
return new Promise((resolve, reject) => {
|
|
server.once("error", reject);
|
|
server.listen(0, "127.0.0.1", () => {
|
|
resolve({ server, port: server.address().port });
|
|
});
|
|
});
|
|
}
|
|
|
|
async function ensureGeoIpFixture() {
|
|
if (process.env.DONUT_E2E_GEOIP_FIXTURE) {
|
|
const fixture = path.resolve(process.env.DONUT_E2E_GEOIP_FIXTURE);
|
|
if (!existsSync(fixture)) {
|
|
throw new Error(`DONUT_E2E_GEOIP_FIXTURE does not exist: ${fixture}`);
|
|
}
|
|
return fixture;
|
|
}
|
|
const toolsDir = path.join(os.tmpdir(), "donut-e2e-tools");
|
|
const fixture = path.join(toolsDir, "GeoLite2-City.mmdb");
|
|
await mkdir(toolsDir, { recursive: true });
|
|
if (existsSync(fixture)) return fixture;
|
|
|
|
log("Downloading GeoLite City E2E dependency");
|
|
const releases = await fetch(
|
|
"https://api.github.com/repos/P3TERX/GeoLite.mmdb/releases",
|
|
{
|
|
headers: { "user-agent": "donut-browser-e2e" },
|
|
signal: AbortSignal.timeout(30_000),
|
|
},
|
|
).then((response) => {
|
|
if (!response.ok) {
|
|
throw new Error(
|
|
`GeoLite release lookup failed with HTTP ${response.status}`,
|
|
);
|
|
}
|
|
return response.json();
|
|
});
|
|
const url = releases
|
|
.flatMap((release) => release.assets ?? [])
|
|
.find((asset) => asset.name.endsWith("-City.mmdb"))?.browser_download_url;
|
|
if (!url) throw new Error("No GeoLite City MMDB asset was found");
|
|
const temporary = `${fixture}.${process.pid}.tmp`;
|
|
await download(url, temporary);
|
|
await rename(temporary, fixture);
|
|
return fixture;
|
|
}
|
|
|
|
function minioUrl() {
|
|
const arch = os.arch() === "arm64" ? "arm64" : "amd64";
|
|
if (process.platform === "darwin") {
|
|
return `https://dl.min.io/server/minio/release/darwin-${arch}/minio`;
|
|
}
|
|
if (process.platform === "linux") {
|
|
return `https://dl.min.io/server/minio/release/linux-${arch}/minio`;
|
|
}
|
|
if (process.platform === "win32") {
|
|
return "https://dl.min.io/server/minio/release/windows-amd64/minio.exe";
|
|
}
|
|
throw new Error(
|
|
`Unsupported MinIO platform ${process.platform}-${os.arch()}`,
|
|
);
|
|
}
|
|
|
|
async function download(url, destination) {
|
|
const transport = url.startsWith("https:") ? https : http;
|
|
await new Promise((resolve, reject) => {
|
|
transport
|
|
.get(url, (response) => {
|
|
if ([301, 302, 307, 308].includes(response.statusCode)) {
|
|
response.resume();
|
|
download(
|
|
new URL(response.headers.location, url).href,
|
|
destination,
|
|
).then(resolve, reject);
|
|
return;
|
|
}
|
|
if (response.statusCode !== 200) {
|
|
response.resume();
|
|
reject(
|
|
new Error(`Failed to download ${url}: HTTP ${response.statusCode}`),
|
|
);
|
|
return;
|
|
}
|
|
const output = createWriteStream(destination, { mode: 0o755 });
|
|
pipeline(response, output).then(resolve, reject);
|
|
})
|
|
.on("error", reject);
|
|
});
|
|
}
|
|
|
|
async function ensureMinio() {
|
|
if (process.env.DONUT_E2E_MINIO_BIN) {
|
|
return path.resolve(process.env.DONUT_E2E_MINIO_BIN);
|
|
}
|
|
const existingHarnessBinary = path.join(
|
|
projectRoot,
|
|
".cache",
|
|
"sync-test",
|
|
isWindows ? "minio.exe" : "minio",
|
|
);
|
|
if (existsSync(existingHarnessBinary)) {
|
|
return existingHarnessBinary;
|
|
}
|
|
const toolsDir = path.join(os.tmpdir(), "donut-e2e-tools");
|
|
const binary = path.join(
|
|
toolsDir,
|
|
`minio-${process.platform}-${os.arch()}${executableSuffix}`,
|
|
);
|
|
await mkdir(toolsDir, { recursive: true });
|
|
if (!existsSync(binary)) {
|
|
log("Downloading isolated MinIO test dependency");
|
|
const temporary = `${binary}.${process.pid}.tmp`;
|
|
await download(minioUrl(), temporary);
|
|
await chmod(temporary, 0o755);
|
|
await rm(binary, { force: true });
|
|
await import("node:fs/promises").then(({ rename }) =>
|
|
rename(temporary, binary),
|
|
);
|
|
}
|
|
return binary;
|
|
}
|
|
|
|
async function startSyncInfrastructure(runRoot, options, records) {
|
|
const minioBinary = await ensureMinio();
|
|
const minioPort = await freePort();
|
|
const minioConsolePort = await freePort();
|
|
const syncPort = await freePort();
|
|
const syncToken = "donut-e2e-sync-token-0123456789abcdef";
|
|
const minio = startProcess(
|
|
"minio",
|
|
minioBinary,
|
|
[
|
|
"server",
|
|
path.join(runRoot, "minio-data"),
|
|
"--address",
|
|
`127.0.0.1:${minioPort}`,
|
|
"--console-address",
|
|
`127.0.0.1:${minioConsolePort}`,
|
|
],
|
|
{
|
|
cwd: projectRoot,
|
|
runRoot,
|
|
verbose: options.verbose,
|
|
env: {
|
|
...process.env,
|
|
MINIO_ROOT_USER: "minioadmin",
|
|
MINIO_ROOT_PASSWORD: "minioadmin",
|
|
MINIO_BROWSER: "off",
|
|
},
|
|
},
|
|
);
|
|
records.push(minio);
|
|
await waitForUrl(
|
|
`http://127.0.0.1:${minioPort}/minio/health/live`,
|
|
30_000,
|
|
minio,
|
|
);
|
|
|
|
const syncRoot = path.join(projectRoot, "donut-sync");
|
|
await rm(path.join(syncRoot, "tsconfig.build.tsbuildinfo"), { force: true });
|
|
await rm(path.join(syncRoot, "dist"), { recursive: true, force: true });
|
|
run("pnpm", ["build"], syncRoot);
|
|
const sync = startProcess("donut-sync", "node", ["dist/main.js"], {
|
|
cwd: syncRoot,
|
|
runRoot,
|
|
verbose: options.verbose,
|
|
env: {
|
|
...process.env,
|
|
PORT: String(syncPort),
|
|
SYNC_TOKEN: syncToken,
|
|
S3_ENDPOINT: `http://127.0.0.1:${minioPort}`,
|
|
S3_REGION: "us-east-1",
|
|
S3_ACCESS_KEY_ID: "minioadmin",
|
|
S3_SECRET_ACCESS_KEY: "minioadmin",
|
|
S3_BUCKET: `donut-e2e-${process.pid}`,
|
|
S3_FORCE_PATH_STYLE: "true",
|
|
},
|
|
});
|
|
records.push(sync);
|
|
await waitForUrl(`http://127.0.0.1:${syncPort}/health`, 30_000, sync);
|
|
return {
|
|
minioUrl: `http://127.0.0.1:${minioPort}`,
|
|
syncUrl: `http://127.0.0.1:${syncPort}`,
|
|
syncToken,
|
|
};
|
|
}
|
|
|
|
async function main() {
|
|
const options = parseArgs(process.argv.slice(2));
|
|
const runRoot = await mkdtemp(path.join(os.tmpdir(), "donut-e2e-"));
|
|
await mkdir(path.join(runRoot, "logs"), { recursive: true });
|
|
const records = [];
|
|
let fixture;
|
|
let failed = false;
|
|
const cleanup = async () => {
|
|
await Promise.all(records.reverse().map(stopProcess));
|
|
if (fixture) {
|
|
await new Promise((resolve) => fixture.server.close(resolve));
|
|
}
|
|
if (!options.keep && !failed) {
|
|
await rm(runRoot, { recursive: true, force: true });
|
|
} else {
|
|
log(`Artifacts retained at ${runRoot}`);
|
|
}
|
|
};
|
|
for (const signal of ["SIGINT", "SIGTERM"]) {
|
|
process.once(signal, () => {
|
|
failed = true;
|
|
cleanup().finally(() => process.exit(signal === "SIGINT" ? 130 : 143));
|
|
});
|
|
}
|
|
|
|
try {
|
|
log(`Run root: ${runRoot}`);
|
|
if (options.build) {
|
|
buildAll();
|
|
} else if (!existsSync(appBinary) || !existsSync(driverBinary)) {
|
|
throw new Error(
|
|
"--no-build requested but the E2E app or driver binary is missing",
|
|
);
|
|
}
|
|
|
|
const driverPort = await freePort();
|
|
const driver = startProcess(
|
|
"tauri-wd",
|
|
driverBinary,
|
|
[
|
|
"--port",
|
|
String(driverPort),
|
|
"--max-sessions",
|
|
"4",
|
|
"--startup-timeout",
|
|
"120",
|
|
"--command-timeout",
|
|
"330",
|
|
"--log",
|
|
options.verbose ? "debug" : "info",
|
|
],
|
|
{
|
|
cwd: webdriverRoot,
|
|
env: process.env,
|
|
runRoot,
|
|
verbose: options.verbose,
|
|
},
|
|
);
|
|
records.push(driver);
|
|
await waitForUrl(`http://127.0.0.1:${driverPort}/status`, 15_000, driver);
|
|
|
|
const needsBrowser =
|
|
options.suite === "browser" || options.suite === "full";
|
|
const geoIpFixture = needsBrowser ? await ensureGeoIpFixture() : null;
|
|
fixture = await startFixtureServer(geoIpFixture);
|
|
let sync = {};
|
|
if (options.suite === "sync" || options.suite === "full") {
|
|
sync = await startSyncInfrastructure(runRoot, options, records);
|
|
}
|
|
|
|
const token = await loadLocalToken();
|
|
if ((options.suite === "browser" || options.suite === "full") && !token) {
|
|
throw new Error("WAYFERN_TEST_TOKEN is required by the browser suite");
|
|
}
|
|
|
|
const files = suiteFiles[options.suite].map((file) =>
|
|
path.join(dirname, "tests", file),
|
|
);
|
|
const testArgs = [
|
|
"--test",
|
|
"--test-concurrency=1",
|
|
"--test-reporter=spec",
|
|
...files,
|
|
];
|
|
const child = spawn(process.execPath, testArgs, {
|
|
cwd: projectRoot,
|
|
env: {
|
|
...process.env,
|
|
DONUT_E2E_RUN_ROOT: runRoot,
|
|
DONUT_E2E_PROJECT_ROOT: projectRoot,
|
|
DONUT_E2E_WEBDRIVER_ROOT: webdriverRoot,
|
|
DONUT_E2E_APP: appBinary,
|
|
DONUT_E2E_DRIVER_URL: `http://127.0.0.1:${driverPort}`,
|
|
DONUT_E2E_FIXTURE_URL: `http://127.0.0.1:${fixture.port}`,
|
|
DONUT_E2E_GEOIP_FIXTURE_READY: geoIpFixture ? "1" : "0",
|
|
WAYFERN_TEST_TOKEN: token,
|
|
DONUT_E2E_SYNC_URL: sync.syncUrl ?? "",
|
|
DONUT_E2E_SYNC_TOKEN: sync.syncToken ?? "",
|
|
DONUT_E2E_MINIO_URL: sync.minioUrl ?? "",
|
|
},
|
|
stdio: "inherit",
|
|
});
|
|
const exitCode = await new Promise((resolve, reject) => {
|
|
child.once("error", reject);
|
|
child.once("exit", (code, signal) => {
|
|
resolve(code ?? (signal ? 1 : 0));
|
|
});
|
|
});
|
|
if (exitCode !== 0) {
|
|
throw new Error(
|
|
`E2E suite ${options.suite} failed with status ${exitCode}`,
|
|
);
|
|
}
|
|
log(`Suite ${options.suite} passed`);
|
|
} catch (error) {
|
|
failed = true;
|
|
process.stderr.write(`[donut-e2e] ERROR: ${error.stack ?? error}\n`);
|
|
process.exitCode = 1;
|
|
} finally {
|
|
await cleanup();
|
|
}
|
|
}
|
|
|
|
await main();
|