@multiplatform.one/cli 5.0.26 → 6.0.0

package/lib/commands/e2e.mjs

@@ -0,0 +1,409 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import spawn from "nano-spawn";
+import YAML from "yaml";
+import yoctoSpinner from "yocto-spinner";
+import crypto from "node:crypto";
+import os from "node:os";
+
+//#region src/commands/e2e.ts
+function sessionFileName(portOffset) {
+	return `.e2e-session-${portOffset}.json`;
+}
+const defaultPorts = {
+	mailpit: [{
+		host: 8025,
+		container: 8025
+	}, {
+		host: 1025,
+		container: 1025
+	}],
+	keycloak: [{
+		host: 8080,
+		container: 8080
+	}],
+	"redis-cache": [{
+		host: 6379,
+		container: 6379
+	}],
+	"redis-queue": [{
+		host: 6380,
+		container: 6379
+	}],
+	postgres: [{
+		host: 5432,
+		container: 5432
+	}],
+	mariadb: [{
+		host: 3306,
+		container: 3306
+	}]
+};
+async function getPresentAppNames(projectRoot) {
+	const appsDir = path.join(projectRoot, "apps");
+	try {
+		const entries = (await fs.readdir(appsDir, { withFileTypes: true })).filter((e) => e.isDirectory());
+		const names = [];
+		for (const e of entries) try {
+			await fs.access(path.join(appsDir, e.name, "package.json"));
+			names.push(e.name);
+		} catch {}
+		return names;
+	} catch {
+		return [];
+	}
+}
+/** Discover app that has Playwright config (for E2E test cwd). Returns app name (e.g. "one") or null. */
+async function discoverE2EApp(projectRoot) {
+	const names = await getPresentAppNames(projectRoot);
+	for (const name of names) {
+		const appPath = path.join(projectRoot, "apps", name);
+		for (const config of [
+			"playwright.config.ts",
+			"playwright.config.js",
+			"playwright.config.mjs"
+		]) try {
+			await fs.access(path.join(appPath, config));
+			return name;
+		} catch {}
+	}
+	return null;
+}
+async function detectServices(projectRoot) {
+	const services = [];
+	services.push("mailpit");
+	if (await dirExists(path.join(projectRoot, "apps", "frappe"))) services.push("mariadb", "redis-cache", "redis-queue");
+	if ((await getPresentAppNames(projectRoot)).includes("keycloak")) services.push("keycloak", "postgres");
+	return services;
+}
+function generateCompose(services, portOffset, projectRoot) {
+	const compose = {
+		services: {},
+		volumes: {}
+	};
+	for (const service of services) {
+		const cfg = buildServiceConfig(service, portOffset, projectRoot);
+		if (cfg) {
+			compose.services[service] = cfg.service;
+			if (cfg.volumes) for (const vol of cfg.volumes) compose.volumes[vol] = {};
+		}
+	}
+	return YAML.stringify(compose);
+}
+function buildServiceConfig(service, portOffset, _projectRoot) {
+	switch (service) {
+		case "mailpit": return {
+			service: {
+				image: "axllent/mailpit",
+				restart: "unless-stopped",
+				ports: offsetPorts("mailpit", portOffset),
+				environment: {
+					MP_MAX_MESSAGES: "5000",
+					MP_SMTP_AUTH_ACCEPT_ANY: "1",
+					MP_SMTP_AUTH_ALLOW_INSECURE: "1"
+				}
+			},
+			volumes: ["mailpit"]
+		};
+		case "keycloak": return { service: {
+			image: "quay.io/keycloak/keycloak:latest",
+			restart: "unless-stopped",
+			ports: offsetPorts("keycloak", portOffset),
+			command: [
+				"start-dev",
+				"--http-relative-path=/auth",
+				`--hostname=http://localhost:${8080 + portOffset}`,
+				"--hostname-strict=false",
+				"--db=postgres",
+				"--db-url-host=postgres",
+				"--db-url-database=keycloak",
+				"--db-username=keycloak",
+				"--db-password=keycloak"
+			],
+			environment: {
+				KEYCLOAK_ADMIN: "admin",
+				KEYCLOAK_ADMIN_PASSWORD: "admin"
+			},
+			depends_on: ["postgres"]
+		} };
+		case "postgres": return {
+			service: {
+				image: "postgres:16.10-alpine",
+				restart: "unless-stopped",
+				ports: offsetPorts("postgres", portOffset),
+				environment: {
+					POSTGRES_DB: "keycloak",
+					POSTGRES_USER: "keycloak",
+					POSTGRES_PASSWORD: "keycloak"
+				}
+			},
+			volumes: ["postgres"]
+		};
+		case "redis-cache": return { service: {
+			image: "docker.io/redis:alpine",
+			restart: "unless-stopped",
+			ports: offsetPorts("redis-cache", portOffset)
+		} };
+		case "redis-queue": return { service: {
+			image: "docker.io/redis:alpine",
+			restart: "unless-stopped",
+			ports: offsetPorts("redis-queue", portOffset)
+		} };
+		case "mariadb": return {
+			service: {
+				image: "mariadb:10.6",
+				restart: "unless-stopped",
+				ports: offsetPorts("mariadb", portOffset),
+				environment: {
+					MARIADB_DATABASE: "frappe",
+					MARIADB_ROOT_PASSWORD: "root",
+					MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: "no"
+				},
+				healthcheck: {
+					test: [
+						"CMD",
+						"mariadb-admin",
+						"ping",
+						"-h",
+						"127.0.0.1",
+						"-uroot",
+						"-proot"
+					],
+					interval: "5s",
+					timeout: "5s",
+					retries: 10
+				}
+			},
+			volumes: ["mariadb"]
+		};
+		default: return null;
+	}
+}
+function offsetPorts(service, offset) {
+	const portDefs = defaultPorts[service];
+	if (!portDefs) return [];
+	return portDefs.map((p) => `${p.host + offset}:${p.container}`);
+}
+async function runE2ESession(projectRoot, options) {
+	const portOffset = options.portOffset ?? 1e3;
+	const projectName = options.project ?? `mp1-test-${crypto.randomBytes(3).toString("hex")}`;
+	const sessionFilePath = path.join(projectRoot, sessionFileName(portOffset));
+	if (options.down) {
+		if (await fileExists(sessionFilePath)) await tearDown(projectRoot, sessionFilePath);
+		else console.log("No active e2e session found.");
+		return;
+	}
+	const spinner = yoctoSpinner({ text: "Detecting services..." }).start();
+	const services = await detectServices(projectRoot);
+	spinner.success(`Detected services: ${services.join(", ")}`);
+	const composeContent = generateCompose(services, portOffset, projectRoot);
+	const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "mp1-e2e-"));
+	const composeFile = path.join(tmpDir, "docker-compose.yaml");
+	await fs.writeFile(composeFile, composeContent);
+	const sessionInfo = {
+		projectName,
+		composeFile,
+		tmpDir,
+		portOffset
+	};
+	await fs.writeFile(sessionFilePath, JSON.stringify(sessionInfo, null, 2));
+	if (!options.noBuild) {
+		const buildSpinner = yoctoSpinner({ text: "Building images..." }).start();
+		try {
+			await spawn("docker", [
+				"compose",
+				"-f",
+				composeFile,
+				"-p",
+				projectName,
+				"build"
+			], {
+				stdio: "pipe",
+				cwd: projectRoot
+			});
+			buildSpinner.success("Images built");
+		} catch {
+			buildSpinner.info("No custom images to build");
+		}
+	}
+	const startSpinner = yoctoSpinner({ text: "Starting test environment..." }).start();
+	try {
+		await spawn("docker", [
+			"compose",
+			"-f",
+			composeFile,
+			"-p",
+			projectName,
+			"up",
+			"-d"
+		], {
+			stdio: "pipe",
+			cwd: projectRoot
+		});
+		startSpinner.success("Test environment started");
+	} catch (err) {
+		startSpinner.error("Failed to start test environment");
+		throw err;
+	}
+	const waitSpinner = yoctoSpinner({ text: "Waiting for services to be ready..." }).start();
+	await waitForServices(services, portOffset);
+	waitSpinner.success("Services ready");
+	const urls = getServiceUrls(services, portOffset);
+	console.log("\nTest environment is ready!\n");
+	for (const [name, url] of Object.entries(urls)) console.log(`  ${name}: ${url}`);
+	console.log("\nTo tear down: mpo test e2e --down\n");
+	if (options.upOnly) return;
+	const e2eApp = await discoverE2EApp(projectRoot);
+	if (!e2eApp) {
+		console.error("No E2E app found: no app under apps/ has playwright.config.ts or playwright.config.js.");
+		await tearDown(projectRoot, sessionFilePath);
+		process.exit(1);
+	}
+	try {
+		const playwrightArgs = ["playwright", "test"];
+		if (options.filter) playwrightArgs.push(options.filter);
+		const baseUrl = `http://localhost:${3e3 + portOffset}`;
+		const frappeUrl = `http://localhost:${8e3 + portOffset}`;
+		await spawn("pnpm", playwrightArgs, {
+			stdio: "inherit",
+			cwd: path.join(projectRoot, "apps", e2eApp),
+			env: {
+				...process.env,
+				BASE_URL: baseUrl,
+				FRAPPE_URL: frappeUrl,
+				FRAPPE_SOCKETIO_PORT: String(9e3 + portOffset),
+				MARIADB_PORT: String(3306 + portOffset),
+				REDIS_CACHE_PORT: String(6379 + portOffset),
+				REDIS_QUEUE_PORT: String(6380 + portOffset),
+				E2E_PORT_OFFSET: String(portOffset)
+			}
+		});
+	} finally {
+		await tearDown(projectRoot, sessionFilePath);
+	}
+}
+async function tearDown(projectRoot, sessionFilePath) {
+	const spinner = yoctoSpinner({ text: "Tearing down test environment..." }).start();
+	try {
+		const { projectName, composeFile, tmpDir } = JSON.parse(await fs.readFile(sessionFilePath, "utf8"));
+		await spawn("docker", [
+			"compose",
+			"-f",
+			composeFile,
+			"-p",
+			projectName,
+			"down",
+			"-v",
+			"--remove-orphans"
+		], {
+			stdio: "pipe",
+			cwd: projectRoot
+		});
+		await fs.rm(tmpDir, {
+			recursive: true,
+			force: true
+		});
+		await fs.rm(sessionFilePath, { force: true });
+		spinner.success("Test environment torn down");
+	} catch {
+		spinner.error("Failed to tear down (session may not exist)");
+		await fs.rm(sessionFilePath, { force: true }).catch(() => {});
+	}
+}
+function getServiceUrls(services, portOffset) {
+	const urls = {};
+	urls.Frontend = `http://localhost:${3e3 + portOffset}`;
+	if (services.includes("keycloak")) urls.Keycloak = `http://localhost:${8080 + portOffset}/auth`;
+	if (services.includes("mailpit")) urls.Mailpit = `http://localhost:${8025 + portOffset}`;
+	if (services.includes("mariadb")) urls["Frappe (MariaDB)"] = `localhost:${3306 + portOffset}`;
+	if (services.includes("redis-cache")) urls["Redis Cache"] = `localhost:${6379 + portOffset}`;
+	if (services.includes("postgres")) urls.Postgres = `localhost:${5432 + portOffset}`;
+	return urls;
+}
+async function dirExists(p) {
+	try {
+		return (await fs.stat(p)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function fileExists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Poll services for readiness instead of relying on a fixed sleep.
+* Checks TCP connectivity for MariaDB, Redis, Postgres, and HTTP for Mailpit/Keycloak.
+*/
+async function waitForServices(services, portOffset) {
+	const maxRetries = 30;
+	const retryInterval = 2e3;
+	const checks = [];
+	for (const service of services) {
+		const ports = defaultPorts[service];
+		if (!ports) continue;
+		for (const portDef of ports) {
+			const hostPort = portDef.host + portOffset;
+			if (service === "mailpit" && portDef.container === 8025) checks.push({
+				name: `${service}:${hostPort}`,
+				check: () => checkHttp(`http://localhost:${hostPort}/api/v1/info`)
+			});
+			else if (service === "keycloak") checks.push({
+				name: `${service}:${hostPort}`,
+				check: () => checkHttp(`http://localhost:${hostPort}/auth/realms/master`)
+			});
+			else checks.push({
+				name: `${service}:${hostPort}`,
+				check: () => checkTcp("localhost", hostPort)
+			});
+		}
+	}
+	for (const { name, check } of checks) {
+		let ready = false;
+		for (let attempt = 0; attempt < maxRetries; attempt++) {
+			try {
+				ready = await check();
+				if (ready) break;
+			} catch {}
+			await sleep(retryInterval);
+		}
+		if (!ready) console.warn(`Warning: ${name} did not become ready within ${maxRetries * retryInterval / 1e3}s`);
+	}
+}
+async function checkTcp(host, port) {
+	const net = await import("node:net");
+	return new Promise((resolve) => {
+		const socket = new net.Socket();
+		socket.setTimeout(2e3);
+		socket.on("connect", () => {
+			socket.destroy();
+			resolve(true);
+		});
+		socket.on("error", () => {
+			socket.destroy();
+			resolve(false);
+		});
+		socket.on("timeout", () => {
+			socket.destroy();
+			resolve(false);
+		});
+		socket.connect(port, host);
+	});
+}
+async function checkHttp(url) {
+	try {
+		return (await fetch(url, { signal: AbortSignal.timeout(2e3) })).ok;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { detectServices, discoverE2EApp, generateCompose, runE2ESession };