plum-e2e 2.4.13 → 2.5.1

package/backend/routes/node.routes.js

@@ -50,10 +50,13 @@ router.post('/execute', authGuard, (req, res) => {
 	const { tags, browser = 'chromium', workers = 1, tests = null } = req.body;
 	const jobId = crypto.randomUUID();
 
+	// path.resolve ensures absolute even if TMPDIR env var is set to a relative path
+	const tmpdir = path.resolve(os.tmpdir());
+
 	// Write test files sent by the primary into a per-job temp dir
 	let tempTestsDir = null;
 	if (tests && Object.keys(tests).length > 0) {
-		tempTestsDir = path.join(os.tmpdir(), `plum-job-${jobId}`);
+		tempTestsDir = path.join(tmpdir, `plum-job-${jobId}`);
 		for (const [rel, content] of Object.entries(tests)) {
 			const dest = path.join(tempTestsDir, rel);
 			fs.mkdirSync(path.dirname(dest), { recursive: true });
@@ -63,7 +66,9 @@ router.post('/execute', authGuard, (req, res) => {
 
 	// Each job writes to its own temp file so concurrent jobs on the same node
 	// cannot clobber each other's reports (shared cucumber_report.json race condition).
-	const reportFile = path.join(os.tmpdir(), `plum-report-${jobId}.json`);
+	const reportFile = path.join(tmpdir, `plum-report-${jobId}.json`);
+	const ssDir = path.join(tmpdir, `plum-ss-${jobId}`);
+	fs.mkdirSync(ssDir, { recursive: true });
 
 	jobs[jobId] = {
 		status: 'running',
@@ -72,7 +77,9 @@ router.post('/execute', authGuard, (req, res) => {
 		startedAt: Date.now(),
 		meta: { tags: tags || '', browser, workers },
 		tempTestsDir,
-		reportFile
+		reportFile,
+		ssDir,
+		pendingScreenshots: []
 	};
 
 	const env = {
@@ -82,10 +89,36 @@ router.post('/execute', authGuard, (req, res) => {
 		BROWSER: browser,
 		REPORT_RUNNERS: String(workers),
 		CUCUMBER_REPORT_FILE: reportFile,
+		PLUM_SS_DIR: ssDir,
 		...(tempTestsDir ? { TESTS_ROOT: tempTestsDir } : {})
 	};
 	if (workers > 1) env.PARALLEL = String(workers);
 
+	const seenSsFiles = new Set();
+	const ssPoller = setInterval(() => {
+		const job = jobs[jobId];
+		if (!job) {
+			clearInterval(ssPoller);
+			return;
+		}
+		try {
+			const files = fs
+				.readdirSync(ssDir)
+				.filter((f) => f.endsWith('.ss.json'))
+				.sort();
+			for (const f of files) {
+				if (seenSsFiles.has(f)) continue;
+				seenSsFiles.add(f);
+				const filePath = path.join(ssDir, f);
+				const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+				job.pendingScreenshots.push(data);
+				try {
+					fs.unlinkSync(filePath);
+				} catch {}
+			}
+		} catch {}
+	}, 400);
+
 	const proc = spawn('npm', ['run', 'test'], { env, shell: true, cwd: BACKEND_DIR });
 	proc.stdout.on('data', (d) => {
 		jobs[jobId].logs += d.toString();
@@ -94,6 +127,7 @@ router.post('/execute', authGuard, (req, res) => {
 		jobs[jobId].logs += d.toString();
 	});
 	proc.on('close', (code) => {
+		clearInterval(ssPoller);
 		jobs[jobId].status = code === 0 ? 'done' : 'error';
 		jobs[jobId].exitCode = code;
 
@@ -103,6 +137,8 @@ router.post('/execute', authGuard, (req, res) => {
 			}
 		} catch {}
 
+		fs.rm(ssDir, { recursive: true, force: true }, () => {});
+
 		if (jobs[jobId].tempTestsDir) {
 			fs.rm(jobs[jobId].tempTestsDir, { recursive: true, force: true }, () => {});
 		}
@@ -132,10 +168,12 @@ router.get('/execute/:jobId', authGuard, (req, res) => {
 	if (!job) return res.status(404).json({ error: 'Job not found' });
 
 	const offset = parseInt(req.query.offset || '0', 10);
+	const screenshots = job.pendingScreenshots.splice(0);
 	res.json({
 		status: job.status,
 		logs: job.logs.slice(offset),
-		exitCode: job.exitCode
+		exitCode: job.exitCode,
+		screenshots
 	});
 });
 

package/backend/routes/reports.routes.js

@@ -21,8 +21,10 @@ const reportService = require('../services/reportService');
 
 router.get('/', async (req, res) => {
 	try {
-		const reports = await reportService.getAllReports();
-		res.json({ reports });
+		const page = Math.max(1, parseInt(req.query.page) || 1);
+		const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 15));
+		const result = await reportService.getReports({ page, limit });
+		res.json(result);
 	} catch {
 		res.status(500).json({ error: 'Failed to fetch reports' });
 	}

package/backend/services/reportService.js

@@ -168,8 +168,15 @@ function processCucumberJson(raw) {
 			const failedStepIndex = visibleSteps.findLastIndex((s) => s.result?.status === 'failed');
 
 			const steps = visibleSteps.map((step, index) => {
+				// AfterStep hook attachments land in step.after[].embeddings in Cucumber.js JSON
+				const afterStepScreenshot =
+					(step.after ?? []).flatMap(
+						(a) => a.embeddings?.filter((e) => e.mime_type === 'image/png') ?? []
+					)[0]?.data ?? null;
+
 				const screenshotData =
 					step.embeddings?.find((e) => e.mime_type === 'image/png')?.data ??
+					afterStepScreenshot ??
 					(index === failedStepIndex ? hookScreenshots[0]?.data : null) ??
 					null;
 
@@ -228,21 +235,39 @@ function processCucumberJson(raw) {
 // 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,
-			testRun: { select: { id: true, title: true } }
-		}
-	});
+const reportListSelect = {
+	id: true,
+	status: true,
+	tags: true,
+	triggerType: true,
+	runners: true,
+	browser: true,
+	runnerName: true,
+	createdAt: true,
+	testRun: { select: { id: true, title: true } }
+};
+
+const TREND_SIZE = 12;
+
+const getReports = async ({ page = 1, limit = 15 } = {}) => {
+	const skip = (page - 1) * limit;
+	const [reports, total, passCount, trend] = await Promise.all([
+		prisma.report.findMany({
+			orderBy: { createdAt: 'desc' },
+			skip,
+			take: limit,
+			select: reportListSelect
+		}),
+		prisma.report.count(),
+		prisma.report.count({ where: { status: 'PASS' } }),
+		prisma.report.findMany({
+			orderBy: { createdAt: 'desc' },
+			take: TREND_SIZE,
+			select: { id: true, status: true, tags: true, createdAt: true }
+		})
+	]);
+	return { reports, total, passCount, failCount: total - passCount, trend };
+};
 
 const getLatestReportId = async () => {
 	const report = await prisma.report.findFirst({
@@ -265,6 +290,7 @@ const getReportDetail = async (id) => {
 			runnerName: true,
 			createdAt: true,
 			content: true,
+			logs: true,
 			testRun: { select: { id: true, title: true } }
 		}
 	});
@@ -300,7 +326,8 @@ const saveReport = async ({
 	runnerName,
 	runnerId,
 	testRunId,
-	forceFail = false
+	forceFail = false,
+	logs = null
 }) => {
 	const normTrigger = normaliseTrigger(triggerType);
 	const { features, status: derivedStatus } = processCucumberJson(rawCucumberJson);
@@ -318,7 +345,8 @@ const saveReport = async ({
 			runnerId: runnerId ?? null,
 			cronJobId,
 			testRunId: testRunId ?? null,
-			content: { features }
+			content: { features },
+			logs: logs || null
 		}
 	});
 	syncAutomatedTags(report.id, features, testRunId ?? null);
@@ -345,7 +373,8 @@ const saveCombinedReport = async ({
 	tag,
 	triggerType,
 	browser,
-	testRunId
+	testRunId,
+	laneLogs = null
 }) => {
 	const featureMap = new Map();
 	for (const content of reports) {
@@ -371,6 +400,14 @@ const saveCombinedReport = async ({
 	}
 	const combined = [...featureMap.values()];
 
+	let combinedLogs = null;
+	if (laneLogs) {
+		const parts = runners
+			.map((r) => (laneLogs[r.id] ? `=== ${r.name} ===\n${laneLogs[r.id]}` : null))
+			.filter(Boolean);
+		if (parts.length > 0) combinedLogs = parts.join('\n\n');
+	}
+
 	return saveReport({
 		rawCucumberJson: combined,
 		tags: tag,
@@ -380,7 +417,8 @@ const saveCombinedReport = async ({
 		runnerName: runners.map((r) => r.name).join(', '),
 		runnerId: null,
 		testRunId: testRunId ?? null,
-		forceFail: reports.some((r) => r === null)
+		forceFail: reports.some((r) => r === null),
+		logs: combinedLogs
 	});
 };
 
@@ -424,7 +462,7 @@ async function syncAutomatedFromFeatures() {
 }
 
 module.exports = {
-	getAllReports,
+	getReports,
 	getLatestReportId,
 	getReportDetail,
 	saveReport,

package/backend/services/runnerService.js

@@ -138,7 +138,13 @@ async function fetchReportContent(runner, jobId, onLog) {
  * @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) {
+async function dispatchAndPoll(
+	runnerId,
+	{ tags, browser, workers },
+	onLog,
+	onDone,
+	onScreenshot = null
+) {
 	// The async poll callback can overlap if a tick takes longer than the interval;
 	// guard so the run resolves exactly once and can't be finalised while a lane
 	// is still in flight.
@@ -195,6 +201,10 @@ async function dispatchAndPoll(runnerId, { tags, browser, workers }, onLog, onDo
 				logOffset += body.logs.length;
 			}
 
+			if (onScreenshot && Array.isArray(body.screenshots)) {
+				for (const ss of body.screenshots) onScreenshot(ss);
+			}
+
 			if (body.status === 'done' || body.status === 'error') {
 				clearInterval(poll);
 				const content = await fetchReportContent(runner, jobId, onLog);

package/backend/websockets/socketHandler.js

@@ -16,12 +16,16 @@
  */
 
 const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const runnerService = require('../services/runnerService');
 const reportService = require('../services/reportService');
 const notificationService = require('../services/notificationService');
 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 { getTestSuites } = require('../services/testService');
 const prisma = require('../services/prisma');
 
 const socketHandler = (io) => {
@@ -110,10 +114,80 @@ const socketHandler = (io) => {
 	});
 };
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSyntheticFailReport(laneName, testIds, reason) {
+	// Build id → scenario title from local feature files so names match the real report.
+	const nameMap = {};
+	try {
+		const { suites } = getTestSuites();
+		for (const suite of suites) {
+			for (const test of suite.tests) {
+				for (const id of Array.isArray(test.id) ? test.id : [test.id]) {
+					nameMap[id] = test.testCase;
+				}
+			}
+		}
+	} catch {}
+
+	return JSON.stringify([
+		{
+			id: 'runner-error',
+			uri: 'runner-error',
+			name: `Runner: ${laneName}`,
+			keyword: 'Feature',
+			elements: testIds.map((id) => ({
+				id: id.replace(/^@/, '').toLowerCase(),
+				// Use real scenario title; fall back to bare ID without @
+				name: nameMap[id] || id.replace(/^@/, ''),
+				keyword: 'Scenario',
+				type: 'scenario',
+				// ids from getTestIdsForTag already carry the @ — don't add a second one
+				tags: [{ name: id.startsWith('@') ? id : `@${id}` }],
+				steps: [
+					{
+						keyword: 'Given ',
+						name: 'the scenario was assigned to this runner',
+						result: {
+							status: 'failed',
+							error_message: `Runner "${laneName}" did not complete: ${reason}`,
+							duration: 0
+						}
+					}
+				]
+			}))
+		}
+	]);
+}
+
 // ---------------------------------------------------------------------------
 // Single built-in runner
 // ---------------------------------------------------------------------------
 
+function startSsPoller(ssDir, onScreenshot) {
+	const seenFiles = new Set();
+	return setInterval(() => {
+		try {
+			const files = fs
+				.readdirSync(ssDir)
+				.filter((f) => f.endsWith('.ss.json'))
+				.sort();
+			for (const f of files) {
+				if (seenFiles.has(f)) continue;
+				seenFiles.add(f);
+				const filePath = path.join(ssDir, f);
+				const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+				onScreenshot(data);
+				try {
+					fs.unlinkSync(filePath);
+				} catch {}
+			}
+		} catch {}
+	}, 400);
+}
+
 function runBuiltIn(
 	io,
 	socket,
@@ -125,12 +199,16 @@ function runBuiltIn(
 	notifyDiscord,
 	notifySlack
 ) {
+	const ssDir = path.join(os.tmpdir(), `plum-ss-${Date.now()}`);
+	fs.mkdirSync(ssDir, { recursive: true });
+
 	const env = {
 		...process.env,
 		TAG: tag,
 		TRIGGER: TRIGGER_TYPE.MANUAL,
 		REPORT_RUNNERS: String(workers),
-		BROWSER: browser
+		BROWSER: browser,
+		PLUM_SS_DIR: ssDir
 	};
 	if (workers > 1) env.PARALLEL = String(workers);
 	if (testRunId) env.TEST_RUN_ID = testRunId;
@@ -138,15 +216,47 @@ function runBuiltIn(
 	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()}`));
+	const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
+		socket.emit('step-screenshot', { stepName, data });
+	});
 
-	proc.on('close', (code) => {
+	let logBuffer = '';
+	proc.stdout.on('data', (d) => {
+		const text = d.toString();
+		logBuffer += text;
+		socket.emit('log', text);
+	});
+	proc.stderr.on('data', (d) => {
+		const text = `[ERROR] ${d.toString()}`;
+		logBuffer += text;
+		socket.emit('log', text);
+	});
+
+	proc.on('close', async (code) => {
+		clearInterval(ssPoller);
+		fs.rm(ssDir, { recursive: true, force: true }, () => {});
 		activeProcs.delete(proc);
 		socket.emit('log', `\nTest finished with code ${code}`);
 		socket.emit('done', code);
 		io.emit('report-ready');
 
+		// Attach accumulated logs to the report generate-report.js just saved
+		try {
+			const latest = await prisma.report.findFirst({
+				where: { triggerType: TRIGGER_TYPE.MANUAL },
+				orderBy: { createdAt: 'desc' },
+				select: { id: true }
+			});
+			if (latest) {
+				await prisma.report.update({
+					where: { id: latest.id },
+					data: { logs: logBuffer || null }
+				});
+			}
+		} catch (e) {
+			console.error('[socket] Failed to save run logs:', e.message);
+		}
+
 		if (notifyDiscord || notifySlack) {
 			prisma.report
 				.findFirst({
@@ -224,6 +334,8 @@ async function runDistributed(
 
 	const total = activeRunnerIds.length;
 	const collectedReports = new Array(total).fill(null);
+	const laneLogs = {};
+	for (const l of laneInfos) laneLogs[l.id] = '';
 	let doneCount = 0;
 	let overallCode = 0;
 
@@ -244,7 +356,8 @@ async function runDistributed(
 					tag,
 					triggerType: TRIGGER_TYPE.MANUAL,
 					browser,
-					testRunId: testRunId ?? null
+					testRunId: testRunId ?? null,
+					laneLogs
 				})
 				.then((saved) => {
 					// Result is authoritative from the merged report, not the exit code —
@@ -278,40 +391,73 @@ async function runDistributed(
 	for (let i = 0; i < activeRunnerIds.length; i++) {
 		const lane = laneInfos[i];
 		const chunkTag = buildTagExpression(chunks[i]);
+		const chunkIds = chunks[i];
 
 		if (lane.id === BUILT_IN_RUNNER_ID) {
+			const laneId = lane.id;
+			const ssDir = path.join(os.tmpdir(), `plum-ss-${Date.now()}-${i}`);
+			fs.mkdirSync(ssDir, { recursive: true });
+
 			const env = {
 				...process.env,
 				TAG: chunkTag,
 				TRIGGER: TRIGGER_REMOTE,
 				BROWSER: browser,
 				REPORT_RUNNERS: String(workers),
-				PLUM_MODE: 'node'
+				PLUM_MODE: 'node',
+				PLUM_SS_DIR: ssDir
 			};
 			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 ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
+				socket.emit('runner-lane-screenshot', { id: laneId, stepName, data });
+			});
+
+			proc.stdout.on('data', (d) => {
+				const text = d.toString();
+				laneLogs[laneId] += text;
+				socket.emit('runner-lane-log', { id: laneId, log: text });
+			});
+			proc.stderr.on('data', (d) => {
+				const text = `[ERROR] ${d.toString()}`;
+				laneLogs[laneId] += text;
+				socket.emit('runner-lane-log', { id: laneId, log: text });
+			});
 
 			const idx = i;
 			proc.on('close', (code) => {
+				clearInterval(ssPoller);
+				fs.rm(ssDir, { recursive: true, force: true }, () => {});
 				activeProcs.delete(proc);
-				onLaneDone(idx, lane.id, code, readCucumberReportFile());
+				const content =
+					readCucumberReportFile() ??
+					makeSyntheticFailReport(lane.name, chunkIds, 'process exited with error');
+				onLaneDone(idx, laneId, code, content);
 			});
 		} else {
 			const idx = i;
+			const laneId = lane.id;
 			runnerService.dispatchAndPoll(
-				lane.id,
+				laneId,
 				{ tags: chunkTag, browser, workers },
-				(log) => socket.emit('runner-lane-log', { id: lane.id, log }),
-				(code, content) => onLaneDone(idx, lane.id, code, content)
+				(log) => {
+					laneLogs[laneId] += log;
+					socket.emit('runner-lane-log', { id: laneId, log });
+				},
+				(code, content) =>
+					onLaneDone(
+						idx,
+						laneId,
+						code,
+						content ??
+							makeSyntheticFailReport(lane.name, chunkIds, 'could not fetch report from runner')
+					),
+				({ stepName, data }) => {
+					socket.emit('runner-lane-screenshot', { id: laneId, stepName, data });
+				}
 			);
 		}
 	}