plum-e2e 1.3.7 → 2.2.0

package/backend/routes/test-runs.routes.js

@@ -0,0 +1,122 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const testRunService = require('../services/testRunService');
+
+router.get('/', jwtAuth, async (req, res, next) => {
+	try {
+		const page = Math.max(1, parseInt(req.query.page) || 1);
+		const limit = Math.min(200, Math.max(1, parseInt(req.query.limit) || 20));
+		const { q, sortBy, sortOrder } = req.query;
+		const result = await testRunService.getAll({ page, limit, q, sortBy, sortOrder });
+		res.json(result);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const run = await testRunService.getById(req.params.id);
+		if (!run) return res.status(404).json({ error: 'Test run not found' });
+		res.json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, async (req, res, next) => {
+	try {
+		const { title, caseIds } = req.body;
+		if (!title) return res.status(400).json({ error: 'title is required' });
+		const run = await testRunService.create({ title, caseIds, createdById: req.user.userId });
+		res.status(201).json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const { title, status, caseIds } = req.body;
+		const run = await testRunService.update(req.params.id, { title, status, caseIds });
+		res.json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/:id/duplicate', jwtAuth, async (req, res, next) => {
+	try {
+		const run = await testRunService.duplicate(req.params.id, { createdById: req.user.userId });
+		if (!run) return res.status(404).json({ error: 'Test run not found' });
+		res.status(201).json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		await testRunService.remove(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/entries/:entryId/assign', jwtAuth, async (req, res, next) => {
+	try {
+		const { userId } = req.body;
+		const entry = await testRunService.assignEntry(req.params.entryId, { userId: userId ?? null });
+		res.json({ entry });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/entries/:entryId/result', jwtAuth, async (req, res, next) => {
+	try {
+		const { status, notes } = req.body;
+		if (!status) return res.status(400).json({ error: 'status is required' });
+		const entry = await testRunService.updateEntry(req.params.entryId, {
+			status,
+			notes,
+			executedById: req.user.userId
+		});
+		res.json({ entry });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/:id/reorder', jwtAuth, async (req, res, next) => {
+	try {
+		const { entryIds } = req.body;
+		if (!Array.isArray(entryIds))
+			return res.status(400).json({ error: 'entryIds must be an array' });
+		await testRunService.reorderEntries(req.params.id, entryIds);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/routes/test-suites.routes.js

@@ -0,0 +1,92 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const testSuiteService = require('../services/testSuiteService');
+
+router.get('/', jwtAuth, async (req, res, next) => {
+	try {
+		if (req.query.withCases === 'true') {
+			const suites = await testSuiteService.getAllWithCases();
+			return res.json({ suites });
+		}
+		if (req.query.q) {
+			const results = await testSuiteService.search(req.query.q);
+			return res.json(results);
+		}
+		const page = Math.max(1, parseInt(req.query.page) || 1);
+		const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 20));
+		const { sortBy, sortOrder } = req.query;
+		const result = await testSuiteService.getAll({ page, limit, sortBy, sortOrder });
+		res.json(result);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const suite = await testSuiteService.getById(req.params.id);
+		if (!suite) return res.status(404).json({ error: 'Suite not found' });
+		res.json({ suite });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, async (req, res, next) => {
+	try {
+		const { name, description, priority } = req.body;
+		if (!name) return res.status(400).json({ error: 'name is required' });
+		const suite = await testSuiteService.create({
+			name,
+			description,
+			priority,
+			createdById: req.user.userId
+		});
+		res.status(201).json({ suite });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const { name, description, priority } = req.body;
+		const suite = await testSuiteService.update(req.params.id, {
+			name,
+			description,
+			priority
+		});
+		res.json({ suite });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		await testSuiteService.remove(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/routes/users.routes.js

@@ -0,0 +1,67 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const { requireAdmin } = require('../middleware/requireAdmin');
+const userService = require('../services/userService');
+
+router.get('/members', jwtAuth, async (req, res, next) => {
+	try {
+		const users = await userService.getMembers();
+		res.json({ users });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/', jwtAuth, requireAdmin, async (req, res, next) => {
+	try {
+		const users = await userService.getAll();
+		res.json({ users });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, requireAdmin, async (req, res, next) => {
+	try {
+		const { name, email, password, role = 'user' } = req.body;
+		if (!name || !email || !password)
+			return res.status(400).json({ error: 'name, email and password are required' });
+		if (!['admin', 'user'].includes(role))
+			return res.status(400).json({ error: 'role must be admin or user' });
+		const user = await userService.createUser({ name, email, password, role });
+		res.status(201).json({ user });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, requireAdmin, async (req, res, next) => {
+	try {
+		if (req.params.id === req.user.userId)
+			return res.status(400).json({ error: 'Cannot delete your own account' });
+		await userService.deleteUser(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/scripts/create-test.js

@@ -64,12 +64,13 @@ async function main() {
 	}
 
 	const pascal = toPascalCase(rawName);
+	const base = pascal.endsWith('Page') ? pascal.slice(0, -4) : pascal;
 	const kebab = toKebabCase(pascal);
 	const suiteTag = `@suite-${kebab}`;
 	const testTag = `@test-${kebab}-1`;
 
 	const featurePath = path.join(testsRoot, 'features', `${pascal}.feature`);
-	const pagePath = path.join(testsRoot, 'pages', `${pascal}Page.ts`);
+	const pagePath = path.join(testsRoot, 'pages', `${base}Page.ts`);
 	const stepsPath = path.join(testsRoot, 'step_definitions', `${pascal}Steps.ts`);
 
 	const conflicts = [featurePath, pagePath, stepsPath].filter(fs.existsSync);
@@ -95,7 +96,7 @@ Feature: ${pascal}
 
 	const page = `import { page } from '../utils/browser';
 
-export class ${pascal}Page {
+export class ${base}Page {
   static async goTo() {
     await page().goto(process.env.BASE_URL as string);
   }
@@ -111,18 +112,18 @@ export class ${pascal}Page {
 `;
 
 	const steps = `import { Given, When, Then } from '@cucumber/cucumber';
-import { ${pascal}Page } from '../pages/${pascal}Page';
+import { ${base}Page } from '../pages/${base}Page';
 
 Given('I am on the ${pascal} page', async () => {
-  await ${pascal}Page.goTo();
+  await ${base}Page.goTo();
 });
 
 When('I perform an action', async () => {
-  await ${pascal}Page.performAction();
+  await ${base}Page.performAction();
 });
 
 Then('I should see the expected result', async () => {
-  await ${pascal}Page.verifyResult();
+  await ${base}Page.verifyResult();
 });
 `;
 

package/backend/scripts/manage-runners.mjs

@@ -32,8 +32,16 @@ import pc from 'picocolors';
 import runnerProcess from '../lib/runnerProcess.js';
 import nodeRegister from '../lib/nodeRegister.js';
 
-const { isLocalUrl, parsePort, pruneDead, statusOf, prepareEnv, startNode, stopNode } =
-	runnerProcess;
+const {
+	isLocalUrl,
+	parsePort,
+	pruneDead,
+	statusOf,
+	prepareEnv,
+	startNode,
+	stopNode,
+	findPidOnPort
+} = runnerProcess;
 const { generateToken, registerWithPrimary } = nodeRegister;
 
 const API_URL = process.env.PLUM_API_URL || 'http://localhost:3001';
@@ -68,6 +76,9 @@ async function deleteRunner(id) {
 /**
  * Resolves the display + control state for every runner: reachability (ping),
  * whether we own a live process for it, and whether we can control it at all.
+ *
+ * Local runners that are online but absent from the registry are automatically
+ * reclaimed by scanning their port for a running process.
  */
 async function describeRunners() {
 	const runners = await fetchRunners();
@@ -77,7 +88,19 @@ async function describeRunners() {
 		runners.map(async (r) => {
 			const online = await pingRunner(r.id);
 			const local = isLocalUrl(r.url);
-			const managed = statusOf(r.id) === 'running';
+			let managed = statusOf(r.id) === 'running';
+
+			if (local && online && !managed) {
+				const port = Number(parsePort(r.url));
+				const pid = findPidOnPort(port);
+				if (pid) {
+					const registry = runnerProcess.loadRegistry();
+					registry[r.id] = { pid, port: String(port), startedAt: Date.now() };
+					runnerProcess.saveRegistry(registry);
+					managed = true;
+				}
+			}
+
 			let state;
 			if (managed) state = 'managed';
 			else if (online) state = 'unmanaged';
@@ -181,7 +204,7 @@ async function runAction(r) {
 		if (cancelled(confirmed) || !confirmed) return;
 		const s = clack.spinner();
 		s.start(`Deleting "${r.name}"...`);
-		if (r.managed) stopNode(r.id);
+		if (r.local) stopNode(r.id, Number(parsePort(r.url)));
 		try {
 			await deleteRunner(r.id);
 			s.stop(pc.green(`Deleted "${r.name}"`));
@@ -194,7 +217,11 @@ async function runAction(r) {
 async function addRunner() {
 	const suggested = `node-${generateToken().slice(0, 6)}`;
 
-	const name = await clack.text({ message: 'Runner name', placeholder: suggested, defaultValue: suggested });
+	const name = await clack.text({
+		message: 'Runner name',
+		placeholder: suggested,
+		defaultValue: suggested
+	});
 	if (cancelled(name)) return;
 
 	const port = await clack.text({
@@ -205,7 +232,11 @@ async function addRunner() {
 	if (cancelled(port)) return;
 
 	const defToken = process.env.NODE_TOKEN || generateToken();
-	const token = await clack.text({ message: 'Auth token', placeholder: defToken, defaultValue: defToken });
+	const token = await clack.text({
+		message: 'Auth token',
+		placeholder: defToken,
+		defaultValue: defToken
+	});
 	if (cancelled(token)) return;
 
 	// Dev nodes run as a bare process on the host; the dockerized primary reaches
@@ -216,9 +247,19 @@ async function addRunner() {
 	s.start(`Registering "${name}" with the primary...`);
 	let id;
 	try {
-		const res = await registerWithPrimary({ primary: API_URL, name, url, token, browser: 'chromium' });
+		const res = await registerWithPrimary({
+			primary: API_URL,
+			name,
+			url,
+			token,
+			browser: 'chromium'
+		});
 		id = res.id;
-		s.stop(res.reused ? pc.green(`Reusing existing runner "${name}"`) : pc.green(`Registered "${name}" (id ${id})`));
+		s.stop(
+			res.reused
+				? pc.green(`Reusing existing runner "${name}"`)
+				: pc.green(`Registered "${name}" (id ${id})`)
+		);
 	} catch (e) {
 		s.stop(pc.red(`Could not register "${name}": ${e.message}`));
 		return;

package/backend/server.js

@@ -53,7 +53,28 @@ async function start() {
 
 	server.listen(port, async () => {
 		console.log(`Backend running on port ${port}${isNodeMode ? ' (node/runner mode)' : ''}`);
-		if (isNodeMode) return; // nodes don't watch files or schedule jobs
+		if (isNodeMode) {
+			// Self-register PID so manage-runners can track and stop this process.
+			const runnerId = process.env.RUNNER_ID;
+			if (runnerId) {
+				const { loadRegistry, saveRegistry } = require('./lib/runnerProcess');
+				const registry = loadRegistry();
+				registry[runnerId] = { pid: process.pid, port: String(port), startedAt: Date.now() };
+				saveRegistry(registry);
+
+				const cleanup = () => {
+					try {
+						const reg = loadRegistry();
+						delete reg[runnerId];
+						saveRegistry(reg);
+					} catch {}
+				};
+				process.once('SIGTERM', cleanup);
+				process.once('SIGINT', cleanup);
+				process.once('exit', cleanup);
+			}
+			return;
+		}
 
 		// chokidar v5+ is ESM-only — use dynamic import to stay compatible with CJS
 		let chokidar;

package/backend/services/cronService.js

@@ -20,6 +20,7 @@ const { spawn } = require('child_process');
 const prisma = require('./prisma');
 const runnerService = require('./runnerService');
 const reportService = require('./reportService');
+const notificationService = require('./notificationService');
 const { BUILT_IN_RUNNER_ID, TRIGGER_REMOTE } = require('../constants/triggers');
 const { getTestIdsForTag, chunkTests, buildTagExpression } = require('../lib/testChunker');
 const { readCucumberReportFile } = require('../lib/reportFilename');
@@ -63,7 +64,7 @@ async function resolveLaneInfos(runnerIds) {
  * 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 }) {
+function runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscord, notifySlack }) {
 	const env = {
 		...process.env,
 		TAG: tags,
@@ -78,6 +79,29 @@ function runSingleBuiltIn({ taskName, tags, workers, browser }) {
 	task.on('close', (code) => {
 		console.log(`Task "${taskName}" finished with code ${code}`);
 		if (_io) _io.emit('cron-done', { taskName, code });
+
+		if (notifyDiscord || notifySlack) {
+			prisma.report
+				.findFirst({
+					where: { triggerType: taskName },
+					orderBy: { createdAt: 'desc' },
+					select: { id: true, status: true, content: true }
+				})
+				.then((report) => {
+					if (!report) return;
+					return notificationService.send({
+						jobName: taskName,
+						status: report.status,
+						content: report.content,
+						browser,
+						tags,
+						reportId: report.id,
+						notifyDiscord,
+						notifySlack
+					});
+				})
+				.catch((e) => console.error(`[cron] Notification failed: ${e.message}`));
+		}
 	});
 }
 
@@ -85,7 +109,15 @@ function runSingleBuiltIn({ taskName, tags, workers, browser }) {
  * 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 }) {
+async function runDistributed({
+	taskName,
+	tags,
+	workers,
+	browser,
+	runnerIds,
+	notifyDiscord,
+	notifySlack
+}) {
 	const allIds = getTestIdsForTag(tags);
 	const chunks = chunkTests(allIds, runnerIds.length);
 
@@ -123,6 +155,20 @@ async function runDistributed({ taskName, tags, workers, browser, runnerIds }) {
 					triggerType: taskName,
 					browser
 				})
+				.then((saved) => {
+					if (saved && (notifyDiscord || notifySlack)) {
+						return notificationService.send({
+							jobName: taskName,
+							status: saved.status,
+							content: saved.content,
+							browser,
+							tags,
+							reportId: saved.id,
+							notifyDiscord,
+							notifySlack
+						});
+					}
+				})
 				.catch((e) => console.error(`[cron] Failed to save combined report: ${e.message}`));
 		}
 	}
@@ -163,7 +209,15 @@ async function runDistributed({ taskName, tags, workers, browser, runnerIds }) {
 // ---------------------------------------------------------------------------
 
 async function runCronJob(job) {
-	const { taskName, tags, workers, browser, runnerIds: runnerIdsStr } = job;
+	const {
+		taskName,
+		tags,
+		workers,
+		browser,
+		runnerIds: runnerIdsStr,
+		notifyDiscord,
+		notifySlack
+	} = job;
 	const runnerIds = parseRunnerIds(runnerIdsStr);
 
 	if (_io) _io.emit('cron-start', { taskName });
@@ -172,9 +226,17 @@ async function runCronJob(job) {
 	const isSingleBuiltIn = runnerIds.length === 1 && runnerIds[0] === BUILT_IN_RUNNER_ID;
 
 	if (isSingleBuiltIn) {
-		runSingleBuiltIn({ taskName, tags, workers, browser });
+		runSingleBuiltIn({ taskName, tags, workers, browser, notifyDiscord, notifySlack });
 	} else {
-		await runDistributed({ taskName, tags, workers, browser, runnerIds });
+		await runDistributed({
+			taskName,
+			tags,
+			workers,
+			browser,
+			runnerIds,
+			notifyDiscord,
+			notifySlack
+		});
 	}
 }
 
@@ -212,7 +274,16 @@ const reload = async () => {
 
 const getAllCronJobs = () => prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } });
 
-const addCronJob = async ({ taskName, cronExpression, tags, workers, browser, runnerIds }) => {
+const addCronJob = async ({
+	taskName,
+	cronExpression,
+	tags,
+	workers,
+	browser,
+	runnerIds,
+	notifyDiscord,
+	notifySlack
+}) => {
 	if (!cronExpression || !taskName || !tags) {
 		return { status: 400, message: 'Missing required parameters' };
 	}
@@ -227,6 +298,8 @@ const addCronJob = async ({ taskName, cronExpression, tags, workers, browser, ru
 			workers: workers ?? 1,
 			browser: browser ?? 'chromium',
 			runnerIds: runnerIdsStr,
+			notifyDiscord: notifyDiscord ?? false,
+			notifySlack: notifySlack ?? false,
 			runnerId: null
 		}
 	});
@@ -248,7 +321,16 @@ const removeCronJob = async (taskName) => {
 
 const updateCronJob = async (
 	oldTaskName,
-	{ taskName: newTaskName, cronExpression, tags, workers, browser, runnerIds }
+	{
+		taskName: newTaskName,
+		cronExpression,
+		tags,
+		workers,
+		browser,
+		runnerIds,
+		notifyDiscord,
+		notifySlack
+	}
 ) => {
 	const job = await prisma.cronJob.findUnique({ where: { taskName: oldTaskName } });
 	if (!job) return { status: 404, message: `Cron job "${oldTaskName}" not found` };
@@ -271,6 +353,8 @@ const updateCronJob = async (
 			workers: workers ?? 1,
 			browser: browser ?? 'chromium',
 			runnerIds: runnerIdsStr,
+			notifyDiscord: notifyDiscord ?? false,
+			notifySlack: notifySlack ?? false,
 			runnerId: null
 		}
 	});