plum-e2e 1.3.7 → 2.2.0

package/backend/services/testSuiteService.js

@@ -0,0 +1,191 @@
+/*
+ * 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 prisma = require('./prisma');
+
+const suiteSelect = {
+	id: true,
+	displayId: true,
+	name: true,
+	description: true,
+	priority: true,
+	createdAt: true,
+	updatedAt: true,
+	createdBy: { select: { id: true, name: true } },
+	_count: { select: { cases: true } }
+};
+
+function suiteOrderBy(sortBy, sortOrder) {
+	const dir = sortOrder === 'desc' ? 'desc' : 'asc';
+	if (sortBy === 'displayId') return { displayId: dir };
+	if (sortBy === 'name') return { name: dir };
+	return { createdAt: dir };
+}
+
+async function getAll({ page = 1, limit = 20, sortBy = 'createdAt', sortOrder = 'desc' } = {}) {
+	const skip = (page - 1) * limit;
+	const orderBy = suiteOrderBy(sortBy, sortOrder);
+	const [suites, total] = await Promise.all([
+		prisma.testSuite.findMany({ select: suiteSelect, orderBy, skip, take: limit }),
+		prisma.testSuite.count()
+	]);
+	return { suites, total };
+}
+
+async function search(q) {
+	const [suites, cases] = await Promise.all([
+		prisma.testSuite.findMany({
+			where: {
+				OR: [
+					{ displayId: { contains: q, mode: 'insensitive' } },
+					{ name: { contains: q, mode: 'insensitive' } }
+				]
+			},
+			select: suiteSelect,
+			orderBy: { createdAt: 'asc' }
+		}),
+		prisma.testCase.findMany({
+			where: {
+				OR: [
+					{ displayId: { contains: q, mode: 'insensitive' } },
+					{ title: { contains: q, mode: 'insensitive' } }
+				]
+			},
+			select: {
+				id: true,
+				displayId: true,
+				title: true,
+				priority: true,
+				isAutomated: true,
+				suite: { select: { id: true, displayId: true, name: true } }
+			},
+			orderBy: { createdAt: 'asc' }
+		})
+	]);
+	return { suites, cases };
+}
+
+async function getAllWithCases() {
+	return prisma.testSuite.findMany({
+		select: {
+			...suiteSelect,
+			cases: {
+				select: {
+					id: true,
+					displayId: true,
+					title: true,
+					priority: true,
+					isAutomated: true
+				},
+				orderBy: { createdAt: 'asc' }
+			}
+		},
+		orderBy: { createdAt: 'asc' }
+	});
+}
+
+async function getById(id) {
+	return prisma.testSuite.findUnique({
+		where: { id },
+		select: {
+			...suiteSelect,
+			cases: {
+				select: {
+					id: true,
+					displayId: true,
+					title: true,
+					priority: true,
+					isAutomated: true,
+					createdAt: true,
+					createdBy: { select: { id: true, name: true } },
+					_count: { select: { steps: true } }
+				},
+				orderBy: { createdAt: 'asc' }
+			}
+		}
+	});
+}
+
+async function create({ name, description, priority, createdById }) {
+	const project = await prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1, suiteSeqNext: 1 },
+		update: { suiteSeqNext: { increment: 1 } },
+		select: { suiteSeqNext: true, testSuitePrefix: true }
+	});
+	const num = String(project.suiteSeqNext).padStart(3, '0');
+	const displayId = `${project.testSuitePrefix}-${num}`;
+
+	return prisma.testSuite.create({
+		data: {
+			displayId,
+			name,
+			description: description ?? '',
+			priority: priority ?? 'Medium',
+			createdById
+		},
+		select: suiteSelect
+	});
+}
+
+async function update(id, { name, description, priority }) {
+	return prisma.testSuite.update({
+		where: { id },
+		data: {
+			...(name !== undefined && { name }),
+			...(description !== undefined && { description }),
+			...(priority !== undefined && { priority })
+		},
+		select: suiteSelect
+	});
+}
+
+async function remove(id) {
+	return prisma.testSuite.delete({ where: { id } });
+}
+
+async function migratePrefix(newPrefix) {
+	const suites = await prisma.testSuite.findMany({
+		select: { id: true, displayId: true },
+		orderBy: { createdAt: 'asc' }
+	});
+	const project = await prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1 },
+		update: { testSuitePrefix: newPrefix },
+		select: { testSuitePrefix: true }
+	});
+	for (let i = 0; i < suites.length; i++) {
+		const num = String(i + 1).padStart(3, '0');
+		await prisma.testSuite.update({
+			where: { id: suites[i].id },
+			data: { displayId: `${newPrefix}-${num}` }
+		});
+	}
+	return project;
+}
+
+module.exports = {
+	getAll,
+	search,
+	getAllWithCases,
+	getById,
+	create,
+	update,
+	remove,
+	migratePrefix
+};

package/backend/services/userService.js

@@ -0,0 +1,114 @@
+/*
+ * 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 bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+const prisma = require('./prisma');
+
+const JWT_SECRET = process.env.JWT_SECRET || 'plum-dev-secret-change-in-production';
+const JWT_EXPIRY = '7d';
+const SALT_ROUNDS = 10;
+
+const userSelect = { id: true, name: true, email: true, role: true, createdAt: true };
+
+async function needsSetup() {
+	const count = await prisma.user.count();
+	return count === 0;
+}
+
+async function createUser({ name, email, password, role = 'user' }) {
+	const hashed = await bcrypt.hash(password, SALT_ROUNDS);
+	return prisma.user.create({
+		data: { name, email, password: hashed, role },
+		select: userSelect
+	});
+}
+
+async function login({ email, password }) {
+	const user = await prisma.user.findUnique({ where: { email } });
+	if (!user) return null;
+	const match = await bcrypt.compare(password, user.password);
+	if (!match) return null;
+	const token = jwt.sign(
+		{ userId: user.id, email: user.email, name: user.name, role: user.role },
+		JWT_SECRET,
+		{ expiresIn: JWT_EXPIRY }
+	);
+	return { token, user: { id: user.id, name: user.name, email: user.email, role: user.role } };
+}
+
+function verifyToken(token) {
+	return jwt.verify(token, JWT_SECRET);
+}
+
+async function getAll() {
+	return prisma.user.findMany({ select: userSelect, orderBy: { createdAt: 'asc' } });
+}
+
+async function getMembers() {
+	return prisma.user.findMany({
+		select: { id: true, name: true },
+		orderBy: { name: 'asc' }
+	});
+}
+
+async function getById(id) {
+	return prisma.user.findUnique({ where: { id }, select: userSelect });
+}
+
+async function updateProfile(id, { name, email }) {
+	if (email) {
+		const conflict = await prisma.user.findFirst({ where: { email, NOT: { id } } });
+		if (conflict) return { ok: false, error: 'Email already in use' };
+	}
+	const user = await prisma.user.update({
+		where: { id },
+		data: {
+			...(name !== undefined && { name }),
+			...(email !== undefined && { email })
+		},
+		select: userSelect
+	});
+	return { ok: true, user };
+}
+
+async function updatePassword(id, { currentPassword, newPassword }) {
+	const user = await prisma.user.findUnique({ where: { id } });
+	if (!user) return { ok: false, error: 'User not found' };
+	const match = await bcrypt.compare(currentPassword, user.password);
+	if (!match) return { ok: false, error: 'Current password is incorrect' };
+	const hashed = await bcrypt.hash(newPassword, SALT_ROUNDS);
+	await prisma.user.update({ where: { id }, data: { password: hashed } });
+	return { ok: true };
+}
+
+async function deleteUser(id) {
+	return prisma.user.delete({ where: { id } });
+}
+
+module.exports = {
+	needsSetup,
+	createUser,
+	login,
+	verifyToken,
+	getAll,
+	getMembers,
+	getById,
+	updateProfile,
+	updatePassword,
+	deleteUser
+};

package/backend/websockets/socketHandler.js

@@ -18,9 +18,11 @@
 const { spawn } = require('child_process');
 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 prisma = require('../services/prisma');
 
 const socketHandler = (io) => {
 	io.on('connection', (socket) => {
@@ -30,12 +32,15 @@ const socketHandler = (io) => {
 		const activeProcs = new Set();
 
 		socket.on('run-test', async (payload, legacyWorkers) => {
-			let tag, workers, browser, runners;
+			let tag, workers, browser, runners, testRunId, notifyDiscord, notifySlack;
 			if (typeof payload === 'string') {
 				tag = payload;
 				workers = Number(legacyWorkers) > 1 ? Number(legacyWorkers) : 1;
 				browser = 'chromium';
 				runners = [BUILT_IN_RUNNER_ID];
+				testRunId = null;
+				notifyDiscord = false;
+				notifySlack = false;
 			} else {
 				tag = payload.tag ?? '';
 				workers = Number(payload.workers) > 1 ? Number(payload.workers) : 1;
@@ -44,6 +49,9 @@ const socketHandler = (io) => {
 					Array.isArray(payload.runners) && payload.runners.length > 0
 						? payload.runners
 						: [BUILT_IN_RUNNER_ID];
+				testRunId = payload.testRunId ?? null;
+				notifyDiscord = payload.notifyDiscord === true;
+				notifySlack = payload.notifySlack === true;
 			}
 
 			// Drop runner ids that no longer exist (e.g. a deleted runner still
@@ -61,9 +69,30 @@ const socketHandler = (io) => {
 			const isSingleBuiltIn = runners.length === 1 && runners[0] === BUILT_IN_RUNNER_ID;
 
 			if (isSingleBuiltIn) {
-				runBuiltIn(io, socket, activeProcs, tag, workers, browser);
+				runBuiltIn(
+					io,
+					socket,
+					activeProcs,
+					tag,
+					workers,
+					browser,
+					testRunId,
+					notifyDiscord,
+					notifySlack
+				);
 			} else {
-				runDistributed(io, socket, activeProcs, tag, workers, browser, runners);
+				runDistributed(
+					io,
+					socket,
+					activeProcs,
+					tag,
+					workers,
+					browser,
+					runners,
+					testRunId,
+					notifyDiscord,
+					notifySlack
+				);
 			}
 		});
 
@@ -85,7 +114,17 @@ const socketHandler = (io) => {
 // Single built-in runner
 // ---------------------------------------------------------------------------
 
-function runBuiltIn(io, socket, activeProcs, tag, workers, browser) {
+function runBuiltIn(
+	io,
+	socket,
+	activeProcs,
+	tag,
+	workers,
+	browser,
+	testRunId,
+	notifyDiscord,
+	notifySlack
+) {
 	const env = {
 		...process.env,
 		TAG: tag,
@@ -94,6 +133,7 @@ function runBuiltIn(io, socket, activeProcs, tag, workers, browser) {
 		BROWSER: browser
 	};
 	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);
@@ -105,8 +145,30 @@ function runBuiltIn(io, socket, activeProcs, tag, workers, browser) {
 		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');
+
+		if (notifyDiscord || notifySlack) {
+			prisma.report
+				.findFirst({
+					where: { triggerType: TRIGGER_TYPE.MANUAL },
+					orderBy: { createdAt: 'desc' },
+					select: { id: true, status: true, content: true }
+				})
+				.then((report) => {
+					if (!report) return;
+					return 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}`));
+		}
 	});
 }
 
@@ -114,7 +176,18 @@ function runBuiltIn(io, socket, activeProcs, tag, workers, browser) {
 // Distributed (multi-runner) path
 // ---------------------------------------------------------------------------
 
-async function runDistributed(io, socket, activeProcs, tag, workers, browser, runnerIds) {
+async function runDistributed(
+	io,
+	socket,
+	activeProcs,
+	tag,
+	workers,
+	browser,
+	runnerIds,
+	testRunId,
+	notifyDiscord,
+	notifySlack
+) {
 	const allIds = getTestIdsForTag(tag);
 	const chunks = chunkTests(allIds, runnerIds.length);
 
@@ -170,7 +243,8 @@ async function runDistributed(io, socket, activeProcs, tag, workers, browser, ru
 					overallCode,
 					tag,
 					triggerType: TRIGGER_TYPE.MANUAL,
-					browser
+					browser,
+					testRunId: testRunId ?? null
 				})
 				.then((saved) => {
 					// Result is authoritative from the merged report, not the exit code —
@@ -178,6 +252,21 @@ async function runDistributed(io, socket, activeProcs, tag, workers, browser, ru
 					// a passing run to "fail" in the live UI.
 					socket.emit('done', { code: saved.status === 'PASS' ? 0 : 1, reportId: saved.id });
 					io.emit('report-ready');
+
+					if (notifyDiscord || notifySlack) {
+						notificationService
+							.send({
+								jobName: 'Manual Run',
+								status: saved.status,
+								content: saved.content,
+								browser,
+								tags: tag,
+								reportId: saved.id,
+								notifyDiscord,
+								notifySlack
+							})
+							.catch((e) => console.error(`[socket] Notification failed: ${e.message}`));
+					}
 				})
 				.catch((e) => {
 					console.error('[runner] Failed to save combined report:', e.message);

package/bin/plum.js

@@ -279,8 +279,75 @@ async function serverStart() {
 	applyServerConfig(cfg);
 	clack.log.info(`UI:                    ${pc.cyan(`http://localhost:${cfg.frontendPort}`)}`);
 	clack.log.info(`Nodes register against: ${pc.dim(cfg.primaryPublicUrl)}`);
-	execSync('docker compose up --build', { cwd: plumRoot, stdio: 'inherit' });
-	clack.outro(pc.dim('Plum server stopped.'));
+
+	execSync('docker compose up --build -d', { cwd: plumRoot, stdio: 'inherit' });
+
+	const apiBase = `http://localhost:${cfg.backendPort}`;
+	const s = clack.spinner();
+	s.start('Waiting for server to be ready…');
+	let ready = false;
+	for (let i = 0; i < 40; i++) {
+		await new Promise((r) => setTimeout(r, 1500));
+		try {
+			const res = await fetch(`${apiBase}/auth/needs-setup`);
+			if (res.ok) {
+				ready = true;
+				break;
+			}
+		} catch {}
+	}
+	s.stop(ready ? pc.green('✓ Server is ready') : pc.yellow('Server may still be starting'));
+
+	if (ready) {
+		let needsSetup = false;
+		try {
+			const res = await fetch(`${apiBase}/auth/needs-setup`);
+			const data = await res.json();
+			needsSetup = data.needsSetup;
+		} catch {}
+
+		if (needsSetup) {
+			clack.log.info('No users found — create your first account to get started.');
+
+			const name = await clack.text({ message: 'Your name', placeholder: 'Jane Smith' });
+			if (clack.isCancel(name)) {
+				clack.log.warn('Skipped. Create a user at /setup in the UI.');
+			} else {
+				const email = await clack.text({
+					message: 'Email address',
+					placeholder: 'jane@example.com'
+				});
+				if (clack.isCancel(email)) {
+					clack.log.warn('Skipped. Create a user at /setup in the UI.');
+				} else {
+					const password = await clack.password({ message: 'Password (min 8 characters)' });
+					if (clack.isCancel(password)) {
+						clack.log.warn('Skipped. Create a user at /setup in the UI.');
+					} else {
+						try {
+							const res = await fetch(`${apiBase}/auth/setup`, {
+								method: 'POST',
+								headers: { 'Content-Type': 'application/json' },
+								body: JSON.stringify({ name, email, password })
+							});
+							if (res.ok) {
+								clack.log.success(`Account created for ${email}. You can now log in.`);
+							} else {
+								const err = await res.json();
+								clack.log.error(`Failed to create account: ${err.error ?? 'unknown error'}`);
+							}
+						} catch (e) {
+							clack.log.error(`Failed to create account: ${e.message}`);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	clack.log.info(pc.dim('Streaming logs (Ctrl+C to detach — server keeps running):'));
+	execSync('docker compose logs -f', { cwd: plumRoot, stdio: 'inherit' });
+	clack.outro(pc.dim('Detached from logs. Run "docker compose down" to stop.'));
 }
 
 async function serverReconfig() {
@@ -588,7 +655,7 @@ switch (command) {
 				const readmeContent = [
 					'# My Tests',
 					'',
-					'Powered by [Plum](https://github.com/silverlunah/plum) — Playwright + Cucumber.',
+					'Powered by [Plum](https://github.com/silverlunah/plum) — Playwright + Cucumber + Test Repository.',
 					'',
 					'## Getting Started',
 					'',
@@ -599,15 +666,16 @@ switch (command) {
 					'   ```bash',
 					'   plum run-test',
 					'   ```',
-					'3. **Write your first test** — edit a file in `tests/features/` or generate a step:',
+					'3. **Write your first test** — scaffold a full feature or generate a single step:',
 					'   ```bash',
-					'   plum create-step',
+					'   plum create-test   # scaffold .feature + Page.ts + Steps.ts',
+					'   plum create-step   # add a single step to an existing file',
 					'   ```',
-					'4. **Start the full UI** (requires Docker) to trigger tests and view reports in the browser:',
+					'4. **Start the full UI** (requires Docker) to trigger tests, view reports, and manage your test repository:',
 					'   ```bash',
 					'   plum start',
 					'   ```',
-					'   Then open **http://localhost:5173**.',
+					'   On first run, Plum asks you to create an admin account. Then open **http://localhost:5173** and sign in.',
 					'',
 					'---',
 					'',
@@ -667,6 +735,19 @@ switch (command) {
 					'',
 					'---',
 					'',
+					'## Test Repository',
+					'',
+					'Plum includes a built-in test case management system. Access it from the **Test Repository** tab in the UI.',
+					'',
+					'- **Test Suites** — Group related test cases. Each suite gets an auto-assigned ID (e.g. `TS-001`).',
+					'- **Test Cases** — Document steps (Action / Test Data / Expected Output), set priority, and assign a Cucumber `@tag` to link automation.',
+					'- **Test Runs** — Build a run from any combination of cases, execute them one by one (pass/fail/blocked/skip), and track history.',
+					'- **Auto-linking** — When a build completes, Plum matches Cucumber scenario tags against `automatedTag` values on your test cases and marks them as automated.',
+					'',
+					'To link a test case to automation, set its **Automated tag** (e.g. `test-login-1`) to match the `@tag` on the Cucumber scenario.',
+					'',
+					'---',
+					'',
 					'## Cucumber & Gherkin Resources',
 					'',
 					'New to Cucumber? These links will get you up to speed quickly:',
@@ -700,8 +781,9 @@ switch (command) {
 				`${pc.bold('Start the full UI')}  ${pc.dim('(requires Docker)')}`,
 				`  ${pc.cyan('plum server start')}`,
 				'',
-				`${pc.bold('Generate a step definition')}`,
-				`  ${pc.cyan('plum create-step')}`
+				`${pc.bold('Generate tests')}`,
+				`  ${pc.cyan('plum create-test')}         scaffold a new feature`,
+				`  ${pc.cyan('plum create-step')}         add a step definition`
 			].join('\n'),
 			'Next steps'
 		);
@@ -885,6 +967,19 @@ switch (command) {
 		break;
 	}
 
+	case 'create-test': {
+		const createTestScript = path.join(plumRoot, 'backend', 'config', 'scripts', 'create-test.mjs');
+		execSync(`node "${createTestScript}"`, {
+			cwd: process.cwd(),
+			stdio: 'inherit',
+			env: {
+				...process.env,
+				TESTS_ROOT: userTestsPath
+			}
+		});
+		break;
+	}
+
 	default:
 		console.log('--------------------------------------\n');
 		console.log('Usage: plum <command>\n');
@@ -918,5 +1013,6 @@ switch (command) {
 		console.log('    --parallel <n>     Run across n parallel workers');
 		console.log('    --browser <name>   chromium | firefox (default: chromium)');
 		console.log('  create-step          Interactively scaffold a new step definition');
+		console.log('  create-test          Scaffold a new .feature + Page.ts + Steps.ts');
 		console.log('\n--------------------------------------\n');
 }