plum-e2e 1.2.3 → 1.3.0

package/backend/services/runnerService.js

@@ -0,0 +1,179 @@
+/*
+ * This file is part of Plum.
+ *
+ * Plum is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plum is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Plum. If not, see https://www.gnu.org/licenses/.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const prisma = require('./prisma');
+
+// ---------------------------------------------------------------------------
+// Runner CRUD
+// ---------------------------------------------------------------------------
+
+const getAll = () => prisma.runner.findMany({ orderBy: { createdAt: 'asc' } });
+
+const create = ({ name, url, token, browser = 'chromium' }) =>
+	prisma.runner.create({ data: { name, url, token, browser } });
+
+const remove = (id) => prisma.runner.delete({ where: { id } });
+
+const update = (id, data) => prisma.runner.update({ where: { id }, data });
+
+const getById = (id) => prisma.runner.findUnique({ where: { id } });
+
+// ---------------------------------------------------------------------------
+// Connectivity
+// ---------------------------------------------------------------------------
+
+async function probe({ url, token }) {
+	const start = Date.now();
+	try {
+		const res = await fetch(`${url}/api/ping`, {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${token}` },
+			signal: AbortSignal.timeout(5000)
+		});
+		return { ok: res.ok, latency: Date.now() - start };
+	} catch (e) {
+		return { ok: false, error: e.message };
+	}
+}
+
+async function ping(id) {
+	const runner = await getById(id);
+	if (!runner) return { ok: false, error: 'Runner not found' };
+	return probe({ url: runner.url, token: runner.token });
+}
+
+// ---------------------------------------------------------------------------
+// Remote execution
+// ---------------------------------------------------------------------------
+
+function collectTestFiles() {
+	const testsDir = path.resolve(process.cwd(), 'tests');
+	const files = {};
+
+	function walk(dir, rel) {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const fullPath = path.join(dir, entry.name);
+			const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) {
+				walk(fullPath, relPath);
+			} else {
+				files[relPath] = fs.readFileSync(fullPath, 'utf8');
+			}
+		}
+	}
+
+	if (fs.existsSync(testsDir)) walk(testsDir, '');
+	return files;
+}
+
+/**
+ * Fetches the raw cucumber JSON content from a finished remote node job.
+ * Returns the content string, or null on failure.
+ */
+async function fetchReportContent(runner, jobId, onLog) {
+	try {
+		const res = await fetch(`${runner.url}/api/report/${jobId}`, {
+			headers: { Authorization: `Bearer ${runner.token}` },
+			signal: AbortSignal.timeout(15000)
+		});
+		if (!res.ok) {
+			onLog(`[WARN] Could not fetch report from "${runner.name}": HTTP ${res.status}\n`);
+			return null;
+		}
+		const { content } = await res.json();
+		return content ?? null;
+	} catch (e) {
+		onLog(`[WARN] Could not fetch report from "${runner.name}": ${e.message}\n`);
+		return null;
+	}
+}
+
+/**
+ * Dispatches a test job to a remote runner node and polls until it finishes.
+ *
+ * @param {string} runnerId
+ * @param {{ tags: string, browser: string, workers: number }} jobParams
+ * @param {(log: string) => void} onLog   Called with each new log chunk
+ * @param {(exitCode: number, reportContent: string|null) => void} onDone
+ */
+async function dispatchAndPoll(runnerId, { tags, browser, workers }, onLog, onDone) {
+	const runner = await getById(runnerId);
+	if (!runner) {
+		onLog(`[ERROR] Runner ${runnerId} not found\n`);
+		onDone(1, null);
+		return;
+	}
+
+	let jobId;
+	try {
+		const res = await fetch(`${runner.url}/api/execute`, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${runner.token}`
+			},
+			body: JSON.stringify({ tags, browser, workers, tests: collectTestFiles() }),
+			signal: AbortSignal.timeout(10000)
+		});
+		if (!res.ok) throw new Error(`HTTP ${res.status}`);
+		jobId = (await res.json()).jobId;
+	} catch (e) {
+		onLog(`[ERROR] Could not reach runner "${runner.name}": ${e.message}\n`);
+		onDone(1, null);
+		return;
+	}
+
+	onLog(`Connected to runner "${runner.name}" — job ${jobId}\n`);
+
+	let logOffset = 0;
+	const poll = setInterval(async () => {
+		try {
+			const res = await fetch(`${runner.url}/api/execute/${jobId}?offset=${logOffset}`, {
+				headers: { Authorization: `Bearer ${runner.token}` },
+				signal: AbortSignal.timeout(8000)
+			});
+			if (!res.ok) return;
+			const body = await res.json();
+
+			if (body.logs) {
+				onLog(body.logs);
+				logOffset += body.logs.length;
+			}
+
+			if (body.status === 'done' || body.status === 'error') {
+				clearInterval(poll);
+				const content = await fetchReportContent(runner, jobId, onLog);
+				onDone(body.exitCode ?? (body.status === 'done' ? 0 : 1), content);
+			}
+		} catch {
+			// transient polling error — keep trying
+		}
+	}, 2500);
+}
+
+module.exports = {
+	getAll,
+	create,
+	remove,
+	update,
+	getById,
+	probe,
+	ping,
+	dispatchAndPoll
+};

package/backend/websockets/socketHandler.js

@@ -16,37 +16,178 @@
  */
 
 const { spawn } = require('child_process');
+const runnerService = require('../services/runnerService');
+const reportService = require('../services/reportService');
+const { TRIGGER_TYPE, BUILT_IN_RUNNER_ID, TRIGGER_REMOTE } = require('../constants/triggers');
+const { getTestIdsForTag, chunkTests, buildTagExpression } = require('../lib/testChunker');
+const { readCucumberReportFile } = require('../lib/reportFilename');
 
 const socketHandler = (io) => {
 	io.on('connection', (socket) => {
 		console.log('WebSocket connection established');
-		socket.on('run-test', (testID, workers) => {
-			const tag = testID ? `${testID}` : '';
-			const runnerCount = Number(workers) > 1 ? Number(workers) : 1;
-			const env = {
-				...process.env,
-				TAG: tag,
-				TRIGGER: 'manual-trigger',
-				REPORT_RUNNERS: String(runnerCount)
-			};
-			if (workers && workers > 1) env.PARALLEL = String(workers);
 
-			const testProcess = spawn('npm', ['run', 'test'], { env });
+		// Track processes spawned for this socket connection so we can cancel them
+		const activeProcs = new Set();
 
-			testProcess.stdout.on('data', (data) => {
-				socket.emit('log', data.toString());
-			});
+		socket.on('run-test', async (payload, legacyWorkers) => {
+			let tag, workers, browser, runners;
+			if (typeof payload === 'string') {
+				tag = payload;
+				workers = Number(legacyWorkers) > 1 ? Number(legacyWorkers) : 1;
+				browser = 'chromium';
+				runners = [BUILT_IN_RUNNER_ID];
+			} else {
+				tag = payload.tag ?? '';
+				workers = Number(payload.workers) > 1 ? Number(payload.workers) : 1;
+				browser = payload.browser ?? 'chromium';
+				runners =
+					Array.isArray(payload.runners) && payload.runners.length > 0
+						? payload.runners
+						: [BUILT_IN_RUNNER_ID];
+			}
 
-			testProcess.stderr.on('data', (data) => {
-				socket.emit('log', `[ERROR] ${data.toString()}`);
-			});
+			const isSingleBuiltIn = runners.length === 1 && runners[0] === BUILT_IN_RUNNER_ID;
 
-			testProcess.on('close', (code) => {
-				socket.emit('log', `\nTest finished with code ${code}`);
-				socket.emit('done', code);
-			});
+			if (isSingleBuiltIn) {
+				runBuiltIn(io, socket, activeProcs, tag, workers, browser);
+			} else {
+				runDistributed(io, socket, activeProcs, tag, workers, browser, runners);
+			}
+		});
+
+		socket.on('cancel-test', () => {
+			if (activeProcs.size === 0) return;
+			for (const proc of activeProcs) {
+				try {
+					proc.kill('SIGTERM');
+				} catch {}
+			}
+			activeProcs.clear();
+			socket.emit('log', '\n[CANCELLED] Test run cancelled by user.\n');
+			socket.emit('done', 130);
 		});
 	});
 };
 
+// ---------------------------------------------------------------------------
+// Single built-in runner
+// ---------------------------------------------------------------------------
+
+function runBuiltIn(io, socket, activeProcs, tag, workers, browser) {
+	const env = {
+		...process.env,
+		TAG: tag,
+		TRIGGER: TRIGGER_TYPE.MANUAL,
+		REPORT_RUNNERS: String(workers),
+		BROWSER: browser
+	};
+	if (workers > 1) env.PARALLEL = String(workers);
+
+	const proc = spawn('npm', ['run', 'test'], { env, shell: true });
+	activeProcs.add(proc);
+
+	proc.stdout.on('data', (d) => socket.emit('log', d.toString()));
+	proc.stderr.on('data', (d) => socket.emit('log', `[ERROR] ${d.toString()}`));
+
+	proc.on('close', (code) => {
+		activeProcs.delete(proc);
+		socket.emit('log', `\nTest finished with code ${code}`);
+		socket.emit('done', code);
+		// Notify all connected clients that a new report is available
+		io.emit('report-ready');
+	});
+}
+
+// ---------------------------------------------------------------------------
+// Distributed (multi-runner) path
+// ---------------------------------------------------------------------------
+
+async function runDistributed(io, socket, activeProcs, tag, workers, browser, runnerIds) {
+	const allIds = getTestIdsForTag(tag);
+	const chunks = chunkTests(allIds, runnerIds.length);
+
+	const laneInfos = await Promise.all(
+		runnerIds.map(async (id) => {
+			if (id === BUILT_IN_RUNNER_ID) return { id, name: 'Built-in', dbId: null };
+			const r = await runnerService.getById(id);
+			return { id, name: r?.name ?? id, dbId: r?.id ?? null };
+		})
+	);
+
+	socket.emit(
+		'runner-lanes-init',
+		laneInfos.map((l, i) => ({ id: l.id, name: l.name, testCount: (chunks[i] || []).length }))
+	);
+
+	const total = runnerIds.length;
+	const collectedReports = new Array(total).fill(null);
+	let doneCount = 0;
+	let overallCode = 0;
+
+	function onLaneDone(idx, laneId, code, reportContent) {
+		if (code !== 0) overallCode = code;
+		collectedReports[idx] = reportContent;
+		socket.emit('runner-lane-status', { id: laneId, status: code === 0 ? 'done' : 'error' });
+		doneCount++;
+
+		if (doneCount === total) {
+			socket.emit('log', `\nAll runners finished (exit ${overallCode})`);
+			socket.emit('done', overallCode);
+
+			reportService
+				.saveCombinedReport({
+					reports: collectedReports,
+					runners: laneInfos,
+					overallCode,
+					tag,
+					triggerType: TRIGGER_TYPE.MANUAL,
+					browser
+				})
+				.then(() => io.emit('report-ready'))
+				.catch((e) => console.error('[runner] Failed to save combined report:', e.message));
+		}
+	}
+
+	for (let i = 0; i < runnerIds.length; i++) {
+		const lane = laneInfos[i];
+		const chunkTag = chunks[i]?.length > 0 ? buildTagExpression(chunks[i]) : tag;
+
+		if (lane.id === BUILT_IN_RUNNER_ID) {
+			const env = {
+				...process.env,
+				TAG: chunkTag,
+				TRIGGER: TRIGGER_REMOTE,
+				BROWSER: browser,
+				REPORT_RUNNERS: String(workers),
+				PLUM_MODE: 'node'
+			};
+			if (workers > 1) env.PARALLEL = String(workers);
+
+			const proc = spawn('npm', ['run', 'test'], { env, shell: true });
+			activeProcs.add(proc);
+
+			proc.stdout.on('data', (d) =>
+				socket.emit('runner-lane-log', { id: lane.id, log: d.toString() })
+			);
+			proc.stderr.on('data', (d) =>
+				socket.emit('runner-lane-log', { id: lane.id, log: `[ERROR] ${d.toString()}` })
+			);
+
+			const idx = i;
+			proc.on('close', (code) => {
+				activeProcs.delete(proc);
+				onLaneDone(idx, lane.id, code, readCucumberReportFile());
+			});
+		} else {
+			const idx = i;
+			runnerService.dispatchAndPoll(
+				lane.id,
+				{ tags: chunkTag, browser, workers },
+				(log) => socket.emit('runner-lane-log', { id: lane.id, log }),
+				(code, content) => onLaneDone(idx, lane.id, code, content)
+			);
+		}
+	}
+}
+
 module.exports = socketHandler;