plum-e2e 1.2.4 → 1.3.1

package/backend/services/cronService.js

@@ -18,6 +18,11 @@
 const cron = require('node-cron');
 const { spawn } = require('child_process');
 const prisma = require('./prisma');
+const runnerService = require('./runnerService');
+const reportService = require('./reportService');
+const { BUILT_IN_RUNNER_ID, TRIGGER_REMOTE } = require('../constants/triggers');
+const { getTestIdsForTag, chunkTests, buildTagExpression } = require('../lib/testChunker');
+const { readCucumberReportFile } = require('../lib/reportFilename');
 
 const scheduledJobs = {};
 let _io = null;
@@ -26,34 +31,159 @@ const setSocketIO = (io) => {
 	_io = io;
 };
 
-function scheduleJob(taskName, cronExpression, tags, workers) {
-	if (scheduledJobs[taskName]) {
-		scheduledJobs[taskName].stop();
-		delete scheduledJobs[taskName];
-	}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
 
-	scheduledJobs[taskName] = cron.schedule(cronExpression, () => {
-		console.log(`Running scheduled task: ${taskName}`);
-		if (_io) _io.emit('cron-start', { taskName });
+/** Parses the stored comma-separated runnerIds string into an array. */
+function parseRunnerIds(str) {
+	if (!str || !str.trim()) return [BUILT_IN_RUNNER_ID];
+	return str
+		.split(',')
+		.map((s) => s.trim())
+		.filter(Boolean);
+}
+
+/** Resolves display names and DB ids for a list of runner IDs. */
+async function resolveLaneInfos(runnerIds) {
+	return 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 };
+		})
+	);
+}
 
-		const env = { ...process.env, TAG: tags, TRIGGER: taskName };
-		if (workers && workers > 1) env.PARALLEL = String(workers);
+// ---------------------------------------------------------------------------
+// Run paths
+// ---------------------------------------------------------------------------
 
-		const task = spawn('npm', ['run', 'test'], { env, shell: true });
-		task.stdout.on('data', (data) => console.log(data.toString()));
-		task.stderr.on('data', (data) => console.error(data.toString()));
-		task.on('close', (code) => {
-			console.log(`Task ${taskName} finished with code ${code}`);
-			if (_io) _io.emit('cron-done', { taskName, code });
-		});
+/**
+ * Single built-in runner — spawns tests locally.
+ * TRIGGER is set to taskName so generate-report.js can persist it correctly.
+ */
+function runSingleBuiltIn({ taskName, tags, workers, browser }) {
+	const env = {
+		...process.env,
+		TAG: tags,
+		TRIGGER: taskName,
+		BROWSER: browser
+	};
+	if (workers > 1) env.PARALLEL = String(workers);
+
+	const task = spawn('npm', ['run', 'test'], { env, shell: true });
+	task.stdout.on('data', (d) => process.stdout.write(d));
+	task.stderr.on('data', (d) => process.stderr.write(d));
+	task.on('close', (code) => {
+		console.log(`Task "${taskName}" finished with code ${code}`);
+		if (_io) _io.emit('cron-done', { taskName, code });
 	});
 }
 
+/**
+ * Multi-runner distributed path — splits tests across nodes and combines reports.
+ * triggerType = taskName so the combined report is correctly attributed.
+ */
+async function runDistributed({ taskName, tags, workers, browser, runnerIds }) {
+	const allIds = getTestIdsForTag(tags);
+	const chunks = chunkTests(allIds, runnerIds.length);
+	const laneInfos = await resolveLaneInfos(runnerIds);
+
+	const collectedReports = new Array(runnerIds.length).fill(null);
+	let doneCount = 0;
+	let overallCode = 0;
+
+	function onLaneDone(idx, code, reportContent) {
+		if (code !== 0) overallCode = code;
+		collectedReports[idx] = reportContent;
+		doneCount++;
+
+		if (doneCount === runnerIds.length) {
+			console.log(`Task "${taskName}" — all runners done (exit ${overallCode})`);
+			if (_io) _io.emit('cron-done', { taskName, code: overallCode });
+
+			reportService
+				.saveCombinedReport({
+					reports: collectedReports,
+					runners: laneInfos,
+					overallCode,
+					tag: tags,
+					triggerType: taskName,
+					browser
+				})
+				.catch((e) => console.error(`[cron] 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]) : tags;
+
+		if (lane.id === BUILT_IN_RUNNER_ID) {
+			const env = {
+				...process.env,
+				TAG: chunkTag,
+				TRIGGER: TRIGGER_REMOTE, // node-mode: file naming only, not persisted to DB
+				BROWSER: browser,
+				PLUM_MODE: 'node'
+			};
+			if (workers > 1) env.PARALLEL = String(workers);
+
+			const task = spawn('npm', ['run', 'test'], { env, shell: true });
+			task.stdout.on('data', (d) => process.stdout.write(d));
+			task.stderr.on('data', (d) => process.stderr.write(d));
+			const idx = i;
+			task.on('close', (code) => onLaneDone(idx, code, readCucumberReportFile()));
+		} else {
+			const idx = i;
+			runnerService.dispatchAndPoll(
+				lane.id,
+				{ tags: chunkTag, browser, workers },
+				(log) => process.stdout.write(log),
+				(code, content) => onLaneDone(idx, code, content)
+			);
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Public: job execution
+// ---------------------------------------------------------------------------
+
+async function runCronJob(job) {
+	const { taskName, tags, workers, browser, runnerIds: runnerIdsStr } = job;
+	const runnerIds = parseRunnerIds(runnerIdsStr);
+
+	if (_io) _io.emit('cron-start', { taskName });
+	console.log(`Running scheduled task: "${taskName}" → runners: ${runnerIds.join(', ')}`);
+
+	const isSingleBuiltIn = runnerIds.length === 1 && runnerIds[0] === BUILT_IN_RUNNER_ID;
+
+	if (isSingleBuiltIn) {
+		runSingleBuiltIn({ taskName, tags, workers, browser });
+	} else {
+		await runDistributed({ taskName, tags, workers, browser, runnerIds });
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Public: scheduling
+// ---------------------------------------------------------------------------
+
+function scheduleJob(job) {
+	const { taskName, cronExpression } = job;
+	if (scheduledJobs[taskName]) {
+		scheduledJobs[taskName].stop();
+		delete scheduledJobs[taskName];
+	}
+	if (job.enabled === false) return; // disabled jobs are not scheduled
+	scheduledJobs[taskName] = cron.schedule(cronExpression, () => runCronJob(job));
+}
+
 const init = async () => {
 	const jobs = await prisma.cronJob.findMany();
-	for (const job of jobs) {
-		scheduleJob(job.taskName, job.cronExpression, job.tags, job.workers);
-	}
+	for (const job of jobs) scheduleJob(job);
 	console.log(`⏰ Scheduled ${jobs.length} cron job(s) from database`);
 };
 
@@ -65,53 +195,107 @@ const reload = async () => {
 	await init();
 };
 
-const getAllCronJobs = async () => {
-	return prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } });
-};
+// ---------------------------------------------------------------------------
+// Public: CRUD
+// ---------------------------------------------------------------------------
+
+const getAllCronJobs = () => prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } });
 
-const addCronJob = async ({ taskName, cronExpression, tags, workers }) => {
+const addCronJob = async ({ taskName, cronExpression, tags, workers, browser, runnerIds }) => {
 	if (!cronExpression || !taskName || !tags) {
 		return { status: 400, message: 'Missing required parameters' };
 	}
+	const runnerIdsStr =
+		Array.isArray(runnerIds) && runnerIds.length > 0 ? runnerIds.join(',') : BUILT_IN_RUNNER_ID;
+
 	const job = await prisma.cronJob.create({
-		data: { taskName, cronExpression, tags, workers: workers ?? 1 }
+		data: {
+			taskName,
+			cronExpression,
+			tags,
+			workers: workers ?? 1,
+			browser: browser ?? 'chromium',
+			runnerIds: runnerIdsStr,
+			runnerId: null
+		}
 	});
-	scheduleJob(job.taskName, job.cronExpression, job.tags, job.workers);
-	return { status: 201, message: `Cron job ${taskName} added` };
+	scheduleJob(job);
+	return { status: 201, message: `Cron job "${taskName}" added` };
 };
 
 const removeCronJob = async (taskName) => {
 	const job = await prisma.cronJob.findUnique({ where: { taskName } });
-	if (!job) return { status: 404, message: `Cron job ${taskName} not found` };
+	if (!job) return { status: 404, message: `Cron job "${taskName}" not found` };
 
 	if (scheduledJobs[taskName]) {
 		scheduledJobs[taskName].stop();
 		delete scheduledJobs[taskName];
 	}
-
 	await prisma.cronJob.delete({ where: { taskName } });
-	return { status: 200, message: `Cron job ${taskName} deleted` };
+	return { status: 200, message: `Cron job "${taskName}" deleted` };
+};
+
+const updateCronJob = async (
+	oldTaskName,
+	{ taskName: newTaskName, cronExpression, tags, workers, browser, runnerIds }
+) => {
+	const job = await prisma.cronJob.findUnique({ where: { taskName: oldTaskName } });
+	if (!job) return { status: 404, message: `Cron job "${oldTaskName}" not found` };
+
+	if (scheduledJobs[oldTaskName]) {
+		scheduledJobs[oldTaskName].stop();
+		delete scheduledJobs[oldTaskName];
+	}
+
+	const effectiveName = newTaskName?.trim() || oldTaskName;
+	const runnerIdsStr =
+		Array.isArray(runnerIds) && runnerIds.length > 0 ? runnerIds.join(',') : BUILT_IN_RUNNER_ID;
+
+	const updated = await prisma.cronJob.update({
+		where: { taskName: oldTaskName },
+		data: {
+			taskName: effectiveName,
+			cronExpression,
+			tags,
+			workers: workers ?? 1,
+			browser: browser ?? 'chromium',
+			runnerIds: runnerIdsStr,
+			runnerId: null
+		}
+	});
+
+	scheduleJob(updated);
+	return { status: 200, message: 'Cron job updated' };
+};
+
+const runJobNow = async (taskName) => {
+	const job = await prisma.cronJob.findUnique({ where: { taskName } });
+	if (!job) return { status: 404, message: `Cron job "${taskName}" not found` };
+	runCronJob(job);
+	return { status: 200 };
 };
 
-const updateCronJob = async (taskName, { cronExpression, tags, workers }) => {
+const toggleCronJob = async (taskName, enabled) => {
 	const job = await prisma.cronJob.findUnique({ where: { taskName } });
-	if (!job) return { status: 404, message: `Cron job ${taskName} not found` };
+	if (!job) return { status: 404, message: `Cron job "${taskName}" not found` };
 
 	const updated = await prisma.cronJob.update({
 		where: { taskName },
-		data: { cronExpression, tags, workers: workers ?? 1 }
+		data: { enabled }
 	});
 
-	scheduleJob(updated.taskName, updated.cronExpression, updated.tags, updated.workers);
-	return { status: 200, message: `Cron job ${taskName} updated` };
+	scheduleJob(updated); // re-schedules if enabled, stops and removes if disabled
+	return { status: 200, enabled: updated.enabled };
 };
 
 module.exports = {
 	init,
 	reload,
+	setSocketIO,
 	getAllCronJobs,
 	addCronJob,
 	removeCronJob,
 	updateCronJob,
-	setSocketIO
+	runJobNow,
+	toggleCronJob
 };

package/backend/services/reportService.js

@@ -17,44 +17,56 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const prisma = require('./prisma');
+const { isScheduledTrigger, normaliseTrigger } = require('../constants/triggers');
+const { SCREENSHOTS_DIR } = require('../lib/reportFilename');
 
-const REPORTS_DIR = path.join(__dirname, '../reports');
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
 
-const getAllReports = async () => {
-	return prisma.report.findMany({ orderBy: { createdAt: 'desc' } });
-};
-
-const getLatestReport = async () => {
-	const report = await prisma.report.findFirst({ orderBy: { createdAt: 'desc' } });
-	return report ? report.fileName : null;
-};
+async function resolveCronJobId(triggerType) {
+	if (!isScheduledTrigger(triggerType)) return null;
+	const job = await prisma.cronJob.findUnique({ where: { taskName: triggerType } });
+	return job?.id ?? null;
+}
 
-const saveReport = async ({ fileName, status, tags, triggerType, runners }) => {
-	let cronJobId = null;
-	const builtInTriggers = ['manual-trigger', 'command-line-trigger', 'undefined'];
-	if (triggerType && !builtInTriggers.includes(triggerType)) {
-		const job = await prisma.cronJob.findUnique({ where: { taskName: triggerType } });
-		if (job) cronJobId = job.id;
+/**
+ * Walks a screenshot filename out of the content JSON tree.
+ * Used when deleting reports to clean up screenshot files.
+ */
+function collectScreenshotFiles(content) {
+	const files = [];
+	for (const feature of content?.features ?? []) {
+		for (const scenario of feature?.scenarios ?? []) {
+			for (const step of scenario?.steps ?? []) {
+				if (step.screenshot) files.push(step.screenshot);
+			}
+		}
 	}
-	return prisma.report.upsert({
-		where: { fileName },
-		create: { fileName, status, tags, triggerType: triggerType || 'undefined', runners, cronJobId },
-		update: {}
-	});
-};
-
-const getReportDetail = (fileName) => {
-	const filePath = path.join(REPORTS_DIR, fileName);
-	if (!filePath.startsWith(REPORTS_DIR)) return null;
-	if (!fs.existsSync(filePath)) return null;
+	return files;
+}
 
-	let raw;
-	try {
-		raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-	} catch {
-		return null;
+function deleteScreenshotFiles(content) {
+	for (const file of collectScreenshotFiles(content)) {
+		const p = path.join(SCREENSHOTS_DIR, file);
+		try {
+			if (fs.existsSync(p)) fs.unlinkSync(p);
+		} catch {}
 	}
+}
+
+/**
+ * Transforms raw Cucumber JSON into our stored format:
+ * - Resolves pass/fail status per step/scenario/feature
+ * - Extracts base64 screenshots to PNG files on disk
+ * - Stores only the filename in the content (not the base64 blob)
+ *
+ * Returns { features, status } where status is 'PASS' | 'FAIL'.
+ */
+function processCucumberJson(raw) {
+	fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
 
 	const features = raw.map((feature) => {
 		const scenarios = (feature.elements || []).map((scenario) => {
@@ -64,17 +76,35 @@ const getReportDetail = (fileName) => {
 				.flatMap((step) => step.embeddings?.filter((e) => e.mime_type === 'image/png') ?? []);
 			const failedStepIndex = visibleSteps.findLastIndex((s) => s.result?.status === 'failed');
 
-			const steps = visibleSteps.map((step, index) => ({
-				keyword: step.keyword.trim(),
-				name: step.name ?? '',
-				status: step.result?.status ?? 'pending',
-				duration: Math.round((step.result?.duration ?? 0) / 1_000_000),
-				error: step.result?.error_message ?? null,
-				screenshot:
+			const steps = visibleSteps.map((step, index) => {
+				const screenshotData =
 					step.embeddings?.find((e) => e.mime_type === 'image/png')?.data ??
 					(index === failedStepIndex ? hookScreenshots[0]?.data : null) ??
-					null
-			}));
+					null;
+
+				let screenshotFile = null;
+				if (screenshotData) {
+					screenshotFile = `${crypto.randomUUID()}.png`;
+					try {
+						fs.writeFileSync(
+							path.join(SCREENSHOTS_DIR, screenshotFile),
+							Buffer.from(screenshotData, 'base64')
+						);
+					} catch (e) {
+						console.error(`[report] Failed to write screenshot: ${e.message}`);
+						screenshotFile = null;
+					}
+				}
+
+				return {
+					keyword: step.keyword.trim(),
+					name: step.name ?? '',
+					status: step.result?.status ?? 'pending',
+					duration: Math.round((step.result?.duration ?? 0) / 1_000_000),
+					error: step.result?.error_message ?? null,
+					screenshot: screenshotFile
+				};
+			});
 
 			const worstStatus = steps.reduce((acc, s) => {
 				const rank = { failed: 3, pending: 2, skipped: 1, passed: 0 };
@@ -91,38 +121,180 @@ const getReportDetail = (fileName) => {
 			};
 		});
 
-		const featureStatus = scenarios.some((s) => s.status === 'failed') ? 'failed' : 'passed';
-
 		return {
 			name: feature.name,
 			uri: feature.uri,
-			status: featureStatus,
+			status: scenarios.some((s) => s.status === 'failed') ? 'failed' : 'passed',
 			scenarios
 		};
 	});
 
-	return { features };
+	const hasFailures = features.some((f) => f.status === 'failed');
+	return { features, status: hasFailures ? 'FAIL' : 'PASS' };
+}
+
+// ---------------------------------------------------------------------------
+// Read operations
+// ---------------------------------------------------------------------------
+
+const getAllReports = () =>
+	prisma.report.findMany({
+		orderBy: { createdAt: 'desc' },
+		select: {
+			id: true,
+			status: true,
+			tags: true,
+			triggerType: true,
+			runners: true,
+			browser: true,
+			runnerName: true,
+			createdAt: true
+		}
+	});
+
+const getLatestReportId = async () => {
+	const report = await prisma.report.findFirst({
+		orderBy: { createdAt: 'desc' },
+		select: { id: true }
+	});
+	return report?.id ?? null;
+};
+
+const getReportDetail = async (id) => {
+	const report = await prisma.report.findUnique({
+		where: { id },
+		select: {
+			id: true,
+			status: true,
+			tags: true,
+			triggerType: true,
+			runners: true,
+			browser: true,
+			runnerName: true,
+			createdAt: true,
+			content: true
+		}
+	});
+	if (!report) return null;
+	const { content, ...meta } = report;
+	return { ...meta, features: content?.features ?? [] };
 };
 
-const deleteReport = async (fileName) => {
-	await prisma.report.delete({ where: { fileName } });
-	const filePath = path.join(REPORTS_DIR, fileName);
-	if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+// ---------------------------------------------------------------------------
+// Write operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Processes raw Cucumber JSON and persists the full report to the database.
+ *
+ * @param {{
+ *   rawCucumberJson: object[],
+ *   tags: string,
+ *   triggerType: string,
+ *   nodeCount?: number,
+ *   browser?: string,
+ *   runnerName?: string,
+ *   runnerId?: string,
+ * }} opts
+ */
+const saveReport = async ({
+	rawCucumberJson,
+	tags,
+	triggerType,
+	nodeCount,
+	browser,
+	runnerName,
+	runnerId
+}) => {
+	const normTrigger = normaliseTrigger(triggerType);
+	const { features, status } = processCucumberJson(rawCucumberJson);
+	const cronJobId = await resolveCronJobId(normTrigger);
+
+	return prisma.report.create({
+		data: {
+			status,
+			tags: (tags ?? '').replace(/^\(|\)$/g, '') || '@all-tests',
+			triggerType: normTrigger,
+			runners: nodeCount ?? 1,
+			browser: browser ?? 'chromium',
+			runnerName: runnerName ?? null,
+			runnerId: runnerId ?? null,
+			cronJobId,
+			content: { features }
+		}
+	});
 };
 
-const deleteReports = async (fileNames) => {
-	await prisma.report.deleteMany({ where: { fileName: { in: fileNames } } });
-	for (const fileName of fileNames) {
-		const filePath = path.join(REPORTS_DIR, fileName);
-		if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+/**
+ * Merges Cucumber JSON from all distributed lanes, processes screenshots,
+ * and persists one combined report to the database.
+ *
+ * @param {{
+ *   reports: (string|null)[],
+ *   runners: { id: string, name: string, dbId: string|null }[],
+ *   overallCode: number,
+ *   tag: string,
+ *   triggerType: string,
+ *   browser: string,
+ * }} opts
+ */
+const saveCombinedReport = async ({ reports, runners, overallCode, tag, triggerType, browser }) => {
+	const featureMap = new Map();
+	for (const content of reports) {
+		if (!content) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(content);
+		} catch {
+			continue;
+		}
+		for (const feature of parsed) {
+			const key = feature.uri ?? feature.id ?? feature.name;
+			if (featureMap.has(key)) {
+				featureMap.get(key).elements.push(...(feature.elements ?? []));
+			} else {
+				featureMap.set(key, { ...feature, elements: [...(feature.elements ?? [])] });
+			}
+		}
 	}
+	const combined = [...featureMap.values()];
+
+	return saveReport({
+		rawCucumberJson: combined,
+		tags: tag,
+		triggerType,
+		nodeCount: runners.length,
+		browser,
+		runnerName: runners.map((r) => r.name).join(', '),
+		runnerId: null
+	});
+};
+
+// ---------------------------------------------------------------------------
+// Delete operations
+// ---------------------------------------------------------------------------
+
+const deleteReport = async (id) => {
+	const report = await prisma.report.findUnique({ where: { id }, select: { content: true } });
+	if (report) deleteScreenshotFiles(report.content);
+	await prisma.report.delete({ where: { id } });
+};
+
+const deleteReports = async (ids) => {
+	const reports = await prisma.report.findMany({
+		where: { id: { in: ids } },
+		select: { content: true }
+	});
+	for (const r of reports) deleteScreenshotFiles(r.content);
+	await prisma.report.deleteMany({ where: { id: { in: ids } } });
 };
 
 module.exports = {
 	getAllReports,
-	getLatestReport,
-	saveReport,
+	getLatestReportId,
 	getReportDetail,
+	saveReport,
+	saveCombinedReport,
 	deleteReport,
 	deleteReports
 };