plum-e2e 2.6.0 → 2.6.1

package/backend/websockets/socketHandler.js

@@ -21,8 +21,10 @@ const os = require('os');
 const path = require('path');
 const runnerService = require('../services/runnerService');
 const reportService = require('../services/reportService');
+const settingsService = require('../services/settingsService');
 const notificationService = require('../services/notificationService');
 const { startSsPoller } = require('../lib/screenshotPoller');
+const { runWithRetries } = require('../lib/retryRunner');
 const { TRIGGER_TYPE, BUILT_IN_RUNNER_ID, TRIGGER_REMOTE } = require('../constants/triggers');
 const { getTestIdsForTag, chunkTests, buildTagExpression } = require('../lib/testChunker');
 const { readCucumberReportFile } = require('../lib/reportFilename');
@@ -167,7 +169,59 @@ function makeSyntheticFailReport(laneName, testIds, reason) {
 // Single built-in runner
 // ---------------------------------------------------------------------------
 
-function runBuiltIn(
+/**
+ * Spawns one `npm run test` attempt for the built-in (local) runner and
+ * resolves once it exits. When `suppressSave` is set, PLUM_MODE=node is
+ * forced so generate-report.js skips its own DB save — used by the retry
+ * path, which persists exactly one merged report itself once every attempt
+ * is done, instead of one row per attempt.
+ */
+function runBuiltInAttempt({
+	activeProcs,
+	socket,
+	currentTag,
+	workers,
+	browser,
+	testRunId,
+	suppressSave,
+	onLog
+}) {
+	return new Promise((resolve) => {
+		const ssDir = path.join(os.tmpdir(), `plum-ss-${Date.now()}`);
+		fs.mkdirSync(ssDir, { recursive: true });
+
+		const env = {
+			...process.env,
+			TAG: currentTag,
+			TRIGGER: TRIGGER_TYPE.MANUAL,
+			REPORT_RUNNERS: String(workers),
+			BROWSER: browser,
+			PLUM_SS_DIR: ssDir
+		};
+		if (workers > 1) env.PARALLEL = String(workers);
+		if (testRunId) env.TEST_RUN_ID = testRunId;
+		if (suppressSave) env.PLUM_MODE = 'node';
+
+		const proc = spawn('npm', ['run', 'test'], { env, shell: true });
+		activeProcs.add(proc);
+
+		const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
+			socket.emit('step-screenshot', { stepName, data });
+		});
+
+		proc.stdout.on('data', (d) => onLog(d.toString()));
+		proc.stderr.on('data', (d) => onLog(`[ERROR] ${d.toString()}`));
+
+		proc.on('close', (code) => {
+			clearInterval(ssPoller);
+			fs.rm(ssDir, { recursive: true, force: true }, () => {});
+			activeProcs.delete(proc);
+			resolve({ code, raw: suppressSave ? readCucumberReportFile() : null });
+		});
+	});
+}
+
+async function runBuiltIn(
 	io,
 	socket,
 	activeProcs,
@@ -178,44 +232,26 @@ function runBuiltIn(
 	notifyDiscord,
 	notifySlack
 ) {
-	const ssDir = path.join(os.tmpdir(), `plum-ss-${Date.now()}`);
-	fs.mkdirSync(ssDir, { recursive: true });
 	const startedAt = Date.now();
-
-	const env = {
-		...process.env,
-		TAG: tag,
-		TRIGGER: TRIGGER_TYPE.MANUAL,
-		REPORT_RUNNERS: String(workers),
-		BROWSER: browser,
-		PLUM_SS_DIR: ssDir
-	};
-	if (workers > 1) env.PARALLEL = String(workers);
-	if (testRunId) env.TEST_RUN_ID = testRunId;
-
-	const proc = spawn('npm', ['run', 'test'], { env, shell: true });
-	activeProcs.add(proc);
-
-	const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
-		socket.emit('step-screenshot', { stepName, data });
-	});
+	const { maxRetries } = await settingsService.getProject();
 
 	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()}`;
+	const onLog = (text) => {
 		logBuffer += text;
 		socket.emit('log', text);
-	});
+	};
 
-	proc.on('close', async (code) => {
-		clearInterval(ssPoller);
-		fs.rm(ssDir, { recursive: true, force: true }, () => {});
-		activeProcs.delete(proc);
+	if (maxRetries === 0) {
+		const { code } = await runBuiltInAttempt({
+			activeProcs,
+			socket,
+			currentTag: tag,
+			workers,
+			browser,
+			testRunId,
+			suppressSave: false,
+			onLog
+		});
 		socket.emit('log', `\nTest finished with code ${code}`);
 		socket.emit('done', code);
 		io.emit('report-ready');
@@ -259,7 +295,57 @@ function runBuiltIn(
 				})
 				.catch((e) => console.error(`[socket] Notification failed: ${e.message}`));
 		}
+		return;
+	}
+
+	const { code, rawJson, attempts } = await runWithRetries({
+		maxRetries,
+		spawnAttempt: async (tagOverride) => {
+			const { code, raw } = await runBuiltInAttempt({
+				activeProcs,
+				socket,
+				currentTag: tagOverride ?? tag,
+				workers,
+				browser,
+				testRunId,
+				suppressSave: true,
+				onLog
+			});
+			return { code, rawJson: raw ? JSON.parse(raw) : [] };
+		},
+		onLog
 	});
+
+	socket.emit('log', `\nTest finished with code ${code}`);
+
+	const report = await reportService.saveReport({
+		rawCucumberJson: rawJson,
+		tags: tag,
+		triggerType: TRIGGER_TYPE.MANUAL,
+		browser,
+		testRunId: testRunId ?? null,
+		logs: logBuffer || null,
+		duration: Date.now() - startedAt,
+		attempts
+	});
+
+	socket.emit('done', code);
+	io.emit('report-ready');
+
+	if (notifyDiscord || notifySlack) {
+		notificationService
+			.send({
+				jobName: 'Manual Run',
+				status: report.status,
+				content: report.content,
+				browser,
+				tags: tag,
+				reportId: report.id,
+				notifyDiscord,
+				notifySlack
+			})
+			.catch((e) => console.error(`[socket] Notification failed: ${e.message}`));
+	}
 }
 
 // ---------------------------------------------------------------------------
@@ -279,6 +365,7 @@ async function runDistributed(
 	notifySlack
 ) {
 	const dispatchStartedAt = Date.now();
+	const { maxRetries } = await settingsService.getProject();
 	const allIds = getTestIdsForTag(tag);
 	const chunks = chunkTests(allIds, runnerIds.length);
 
@@ -315,14 +402,16 @@ async function runDistributed(
 
 	const total = activeRunnerIds.length;
 	const collectedReports = new Array(total).fill(null);
+	const laneAttempts = new Array(total).fill(null);
 	const laneLogs = {};
 	for (const l of laneInfos) laneLogs[l.id] = '';
 	let doneCount = 0;
 	let overallCode = 0;
 
-	function onLaneDone(idx, laneId, code, reportContent) {
+	function onLaneDone(idx, laneId, code, reportContent, attempts = null) {
 		if (code !== 0) overallCode = code;
 		collectedReports[idx] = reportContent;
+		laneAttempts[idx] = attempts;
 		socket.emit('runner-lane-status', { id: laneId, status: code === 0 ? 'done' : 'error' });
 		doneCount++;
 
@@ -339,7 +428,8 @@ async function runDistributed(
 					browser,
 					testRunId: testRunId ?? null,
 					laneLogs,
-					duration: Date.now() - dispatchStartedAt
+					duration: Date.now() - dispatchStartedAt,
+					attemptsByLane: laneAttempts
 				})
 				.then((saved) => {
 					// Result is authoritative from the merged report, not the exit code —
@@ -376,70 +466,89 @@ async function runDistributed(
 		const chunkIds = chunks[i];
 
 		if (lane.id === BUILT_IN_RUNNER_ID) {
+			const idx = i;
 			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_SS_DIR: ssDir
+			const onLog = (text) => {
+				laneLogs[laneId] += text;
+				socket.emit('runner-lane-log', { id: laneId, log: text });
 			};
-			if (workers > 1) env.PARALLEL = String(workers);
 
-			const proc = spawn('npm', ['run', 'test'], { env, shell: true });
-			activeProcs.add(proc);
-
-			const ssPoller = startSsPoller(ssDir, ({ stepName, data }) => {
-				socket.emit('runner-lane-screenshot', { id: laneId, stepName, data });
-			});
+			const spawnBuiltInLaneAttempt = (currentTag) =>
+				new Promise((resolve) => {
+					const ssDir = path.join(os.tmpdir(), `plum-ss-${Date.now()}-${idx}`);
+					fs.mkdirSync(ssDir, { recursive: true });
+
+					const env = {
+						...process.env,
+						TAG: currentTag,
+						TRIGGER: TRIGGER_REMOTE,
+						BROWSER: browser,
+						REPORT_RUNNERS: String(workers),
+						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);
+
+					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 });
-			});
+					proc.stdout.on('data', (d) => onLog(d.toString()));
+					proc.stderr.on('data', (d) => onLog(`[ERROR] ${d.toString()}`));
+
+					proc.on('close', (code) => {
+						clearInterval(ssPoller);
+						fs.rm(ssDir, { recursive: true, force: true }, () => {});
+						activeProcs.delete(proc);
+						const content =
+							readCucumberReportFile() ??
+							makeSyntheticFailReport(lane.name, chunkIds, 'process exited with error');
+						resolve({ code, rawJson: JSON.parse(content) });
+					});
+				});
 
-			const idx = i;
-			proc.on('close', (code) => {
-				clearInterval(ssPoller);
-				fs.rm(ssDir, { recursive: true, force: true }, () => {});
-				activeProcs.delete(proc);
-				const content =
-					readCucumberReportFile() ??
-					makeSyntheticFailReport(lane.name, chunkIds, 'process exited with error');
-				onLaneDone(idx, laneId, code, content);
-			});
+			runWithRetries({
+				maxRetries,
+				spawnAttempt: (t) => spawnBuiltInLaneAttempt(t ?? chunkTag),
+				onLog
+			}).then(({ code, rawJson, attempts }) =>
+				onLaneDone(idx, laneId, code, JSON.stringify(rawJson), attempts)
+			);
 		} else {
 			const idx = i;
 			const laneId = lane.id;
-			runnerService.dispatchAndPoll(
-				laneId,
-				{ tags: chunkTag, browser, workers },
-				(log) => {
-					laneLogs[laneId] += log;
-					socket.emit('runner-lane-log', { id: laneId, log });
-				},
-				(code, content) =>
-					onLaneDone(
-						idx,
+			const onLog = (log) => {
+				laneLogs[laneId] += log;
+				socket.emit('runner-lane-log', { id: laneId, log });
+			};
+
+			const spawnRemoteLaneAttempt = (currentTag) =>
+				new Promise((resolve) => {
+					runnerService.dispatchAndPoll(
 						laneId,
-						code,
-						content ??
-							makeSyntheticFailReport(lane.name, chunkIds, 'could not fetch report from runner')
-					),
-				({ stepName, data }) => {
-					socket.emit('runner-lane-screenshot', { id: laneId, stepName, data });
-				}
+						{ tags: currentTag, browser, workers },
+						onLog,
+						(code, content) => {
+							const raw =
+								content ??
+								makeSyntheticFailReport(lane.name, chunkIds, 'could not fetch report from runner');
+							resolve({ code, rawJson: JSON.parse(raw) });
+						},
+						({ stepName, data }) => {
+							socket.emit('runner-lane-screenshot', { id: laneId, stepName, data });
+						}
+					);
+				});
+
+			runWithRetries({
+				maxRetries,
+				spawnAttempt: (t) => spawnRemoteLaneAttempt(t ?? chunkTag),
+				onLog
+			}).then(({ code, rawJson, attempts }) =>
+				onLaneDone(idx, laneId, code, JSON.stringify(rawJson), attempts)
 			);
 		}
 	}

package/frontend/src/lib/api/runners.js

@@ -51,6 +51,16 @@ export async function pingRunner(id) {
 	return res.json();
 }
 
+export async function stopRunner(id) {
+	const res = await fetch(`${API_BASE}/runners/${id}/stop`, { method: 'POST' });
+	return res.json();
+}
+
+export async function restartRunner(id) {
+	const res = await fetch(`${API_BASE}/runners/${id}/restart`, { method: 'POST' });
+	return res.json();
+}
+
 export async function probeRunner(url, token) {
 	const res = await fetch(`${API_BASE}/runners/probe`, {
 		method: 'POST',

package/frontend/src/lib/api/settings.js

@@ -24,15 +24,15 @@ function authHeaders() {
 
 export async function fetchProject() {
 	const res = await fetch(`${API_BASE}/settings/project`);
-	if (!res.ok) return { name: '', logoUrl: '', timezone: 'UTC' };
+	if (!res.ok) return { name: '', logoUrl: '', timezone: 'UTC', maxRetries: 0 };
 	return res.json();
 }
 
-export async function saveProject({ name, logoUrl, timezone }) {
+export async function saveProject({ name, logoUrl, timezone, maxRetries }) {
 	const res = await fetch(`${API_BASE}/settings/project`, {
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
-		body: JSON.stringify({ name, logoUrl, timezone })
+		body: JSON.stringify({ name, logoUrl, timezone, maxRetries })
 	});
 	return res.json();
 }

package/frontend/src/lib/constants.js

@@ -41,6 +41,7 @@ export const REDIRECT_DELAY_MS = 3000;
 
 export const WORKERS_MIN = 1;
 export const WORKERS_MAX = 10;
+export const MAX_TEST_RETRIES = 5;
 export const RUN_PICKER_LIMIT = 200;
 export const RUN_TAG_DISPLAY_LIMIT = 5;
 export const CASE_HISTORY_BARS_MAX = 20;

package/frontend/src/routes/reports/[id]/+page.svelte

@@ -430,6 +430,14 @@
 									{#if group.scenarios.length > 1}
 										<span class="scenario-count">{group.scenarios.length} cases</span>
 									{/if}
+									{#if group.scenarios[0]?.attempts > 1}
+										<span
+											class="scenario-count"
+											title="Failed and was automatically retried before the final result"
+										>
+											{group.scenarios[0].attempts} attempts
+										</span>
+									{/if}
 								</span>
 
 								<div class="scenario-tags">

package/frontend/src/routes/settings/+page.svelte

@@ -39,7 +39,9 @@
 		updateRunner,
 		deleteRunner,
 		pingRunner,
-		probeRunner
+		probeRunner,
+		stopRunner,
+		restartRunner
 	} from '$lib/api/runners';
 	import { fetchPrefixes, savePrefixes, migratePrefixes } from '$lib/api/repository';
 	import { updateProfile, changePassword } from '$lib/api/auth';
@@ -51,7 +53,7 @@
 	import { builtInEnabled } from '$lib/stores/runner';
 	import { auth } from '$lib/stores/auth';
 	import { theme } from '$lib/stores/theme';
-	import { API_BASE, BROWSERS, TOAST_TIMEOUT_MS } from '$lib/constants';
+	import { API_BASE, BROWSERS, TOAST_TIMEOUT_MS, MAX_TEST_RETRIES } from '$lib/constants';
 	import Button from '$lib/components/ui/Button.svelte';
 	import Toast from '$lib/components/ui/Toast.svelte';
 	import ConfirmModal from '$lib/components/ui/ConfirmModal.svelte';
@@ -69,7 +71,7 @@
 		} catch {}
 	}
 
-	let project = { name: '', logoUrl: '', timezone: 'UTC' };
+	let project = { name: '', logoUrl: '', timezone: 'UTC', maxRetries: 0 };
 	let projectSaving = false;
 	let toast = null;
 
@@ -142,6 +144,8 @@
 	let runnerFormSaving = false;
 	let runnerFormOpen = false;
 	let pingResults = {};
+	let stoppingId = null;
+	let restartingId = null;
 	let editingId = null;
 	let editForm = { name: '', url: '', token: '', browser: 'chromium' };
 	let editFormError = '';
@@ -280,6 +284,51 @@
 		}
 	}
 
+	async function refreshPing(id) {
+		pingResults = { ...pingResults, [id]: { loading: true } };
+		try {
+			const result = await pingRunner(id);
+			pingResults = { ...pingResults, [id]: { ...result, loading: false } };
+		} catch {
+			pingResults = { ...pingResults, [id]: { ok: false, error: 'Network error', loading: false } };
+		}
+	}
+
+	async function handleStopRunner(id, name) {
+		stoppingId = id;
+		try {
+			const result = await stopRunner(id);
+			if (result.ok) {
+				showToast('success', `Runner "${name}" stopped.`);
+			} else {
+				showToast('error', `Could not stop "${name}": ${result.error ?? 'unknown error'}`);
+			}
+		} catch {
+			showToast('error', `Could not stop "${name}".`);
+		} finally {
+			stoppingId = null;
+			refreshPing(id);
+		}
+	}
+
+	async function handleRestartRunner(id, name) {
+		restartingId = id;
+		try {
+			const result = await restartRunner(id);
+			if (result.ok) {
+				showToast('success', `Runner "${name}" restarting…`);
+			} else {
+				showToast('error', `Could not restart "${name}": ${result.error ?? 'unknown error'}`);
+			}
+		} catch {
+			showToast('error', `Could not restart "${name}".`);
+		} finally {
+			restartingId = null;
+			// Give the replacement process a moment to bind before checking on it.
+			setTimeout(() => refreshPing(id), 2000);
+		}
+	}
+
 	function startEdit(r) {
 		editingId = r.id;
 		editForm = { name: r.name, url: r.url, token: r.token, browser: r.browser };
@@ -717,6 +766,24 @@
 						</select>
 					</div>
 
+					<div class="field">
+						<label class="field-label" for="project-max-retries">
+							<span>Retry failed tests</span>
+							<span class="field-hint">
+								Automatically re-run failed scenarios up to this many times before finalizing the
+								report. 0 disables retries.
+							</span>
+						</label>
+						<input
+							id="project-max-retries"
+							type="number"
+							class="field-input"
+							min="0"
+							max={MAX_TEST_RETRIES}
+							bind:value={project.maxRetries}
+						/>
+					</div>
+
 					<!-- Dark mode toggle -->
 					<div class="toggle-row">
 						<div class="toggle-info">
@@ -878,6 +945,20 @@
 										<p class="runner-card-url">{r.url}</p>
 										<div class="runner-card-actions">
 											<Button variant="ghost" size="sm" on:click={() => startEdit(r)}>Edit</Button>
+											<Button
+												variant="ghost"
+												size="sm"
+												disabled={restartingId === r.id}
+												on:click={() => handleRestartRunner(r.id, r.name)}
+												>{restartingId === r.id ? 'Restarting…' : 'Restart'}</Button
+											>
+											<Button
+												variant="ghost"
+												size="sm"
+												disabled={stoppingId === r.id}
+												on:click={() => handleStopRunner(r.id, r.name)}
+												>{stoppingId === r.id ? 'Stopping…' : 'Stop'}</Button
+											>
 											<Button
 												variant="danger"
 												size="sm"
@@ -1985,6 +2066,7 @@
 	.runner-card-actions {
 		display: flex;
 		align-items: center;
+		flex-wrap: wrap;
 		gap: 0.375rem;
 		padding-left: calc(13px + 0.5rem);
 		margin-top: 0.125rem;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "plum-e2e",
-	"version": "2.6.0",
+	"version": "2.6.1",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/silverlunah/plum.git"