plum-e2e 2.1.0 → 2.2.0

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
 		}
 	});

package/backend/services/notificationService.js

@@ -0,0 +1,163 @@
+/*
+ * 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 settingsService = require('./settingsService');
+
+function countScenarios(content) {
+	try {
+		// DB stores the processed format: { features: [{ scenarios: [{ status: 'passed'|'failed' }] }] }
+		const features = content?.features ?? (Array.isArray(content) ? content : []);
+		let passed = 0;
+		let failed = 0;
+		let total = 0;
+		for (const feature of features) {
+			for (const scenario of feature.scenarios ?? []) {
+				total++;
+				if (scenario.status === 'passed') passed++;
+				else failed++;
+			}
+		}
+		return { passed, failed, total };
+	} catch {
+		return { passed: 0, failed: 0, total: 0 };
+	}
+}
+
+function buildDiscordPayload({ jobName, status, counts, browser, tags, reportUrl }) {
+	const isPass = status === 'PASS';
+	// Discord colour integers: green 3066993, red 15158332
+	const color = isPass ? 3066993 : 15158332;
+	const fields = [
+		{ name: 'Status', value: isPass ? '✅  PASS' : '❌  FAIL', inline: true },
+		{
+			name: 'Results',
+			value: `${counts.passed} / ${counts.total} passed`,
+			inline: true
+		},
+		{ name: 'Browser', value: browser ?? 'chromium', inline: true },
+		{ name: 'Tags', value: tags || '(all tests)', inline: false }
+	];
+	if (reportUrl) {
+		fields.push({ name: 'Report', value: `[View Report](${reportUrl})`, inline: false });
+	}
+
+	const embed = { title: jobName, color, fields, timestamp: new Date().toISOString() };
+	if (reportUrl) embed.url = reportUrl;
+	return { embeds: [embed] };
+}
+
+function buildSlackPayload({ jobName, status, counts, browser, tags, reportUrl }) {
+	const isPass = status === 'PASS';
+	const icon = isPass ? '✅' : '❌';
+	const blocks = [
+		{
+			type: 'section',
+			text: {
+				type: 'mrkdwn',
+				text: `${icon} *${jobName}* — ${isPass ? 'PASS' : 'FAIL'}\n${counts.passed} / ${counts.total} scenarios passed`
+			}
+		},
+		{
+			type: 'section',
+			fields: [
+				{ type: 'mrkdwn', text: `*Browser:*\n${browser ?? 'chromium'}` },
+				{ type: 'mrkdwn', text: `*Tags:*\n${tags || '(all tests)'}` }
+			]
+		}
+	];
+	if (reportUrl) {
+		blocks.push({
+			type: 'actions',
+			elements: [
+				{
+					type: 'button',
+					text: { type: 'plain_text', text: 'View Report', emoji: true },
+					url: reportUrl
+				}
+			]
+		});
+	}
+	return { blocks };
+}
+
+async function postJson(url, body) {
+	const res = await fetch(url, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(body),
+		signal: AbortSignal.timeout(8000)
+	});
+	if (!res.ok) {
+		console.error(`[notify] Webhook responded ${res.status}: ${url}`);
+	}
+}
+
+/**
+ * Sends Discord and/or Slack notifications for a completed test run.
+ *
+ * @param {{ jobName: string, status: string, content: object, browser: string,
+ *           tags: string, reportId: number|null,
+ *           notifyDiscord: boolean, notifySlack: boolean }} opts
+ */
+async function send({
+	jobName,
+	status,
+	content,
+	browser,
+	tags,
+	reportId,
+	notifyDiscord,
+	notifySlack
+}) {
+	if (!notifyDiscord && !notifySlack) return;
+
+	let discordWebhookUrl, slackWebhookUrl, notifyPublicUrl;
+	try {
+		({ discordWebhookUrl, slackWebhookUrl, notifyPublicUrl } = await settingsService.getWebhooks());
+	} catch (e) {
+		console.error(`[notify] Could not load webhook settings: ${e.message}`);
+		return;
+	}
+
+	const reportUrl =
+		notifyPublicUrl && reportId
+			? `${notifyPublicUrl.replace(/\/$/, '')}/reports/${reportId}`
+			: null;
+
+	const counts = countScenarios(content);
+	const data = { jobName, status, counts, browser, tags, reportUrl };
+
+	const tasks = [];
+	if (notifyDiscord && discordWebhookUrl) {
+		tasks.push(
+			postJson(discordWebhookUrl, buildDiscordPayload(data)).catch((e) =>
+				console.error(`[notify] Discord failed: ${e.message}`)
+			)
+		);
+	}
+	if (notifySlack && slackWebhookUrl) {
+		tasks.push(
+			postJson(slackWebhookUrl, buildSlackPayload(data)).catch((e) =>
+				console.error(`[notify] Slack failed: ${e.message}`)
+			)
+		);
+	}
+
+	await Promise.all(tasks);
+}
+
+module.exports = { send };

package/backend/services/settingsService.js

@@ -49,4 +49,32 @@ const updateTestPrefixes = async ({ testCasePrefix, testSuitePrefix }) => {
 	});
 };
 
-module.exports = { getProject, updateProject, getTestPrefixes, updateTestPrefixes };
+const getWebhooks = async () => {
+	const project = await getProject();
+	return {
+		discordWebhookUrl: project.discordWebhookUrl ?? '',
+		slackWebhookUrl: project.slackWebhookUrl ?? '',
+		notifyPublicUrl: project.notifyPublicUrl ?? ''
+	};
+};
+
+const updateWebhooks = async ({ discordWebhookUrl, slackWebhookUrl, notifyPublicUrl }) => {
+	return prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1 },
+		update: {
+			discordWebhookUrl: discordWebhookUrl ?? '',
+			slackWebhookUrl: slackWebhookUrl ?? '',
+			notifyPublicUrl: notifyPublicUrl ?? ''
+		}
+	});
+};
+
+module.exports = {
+	getProject,
+	updateProject,
+	getTestPrefixes,
+	updateTestPrefixes,
+	getWebhooks,
+	updateWebhooks
+};

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,13 +32,15 @@ const socketHandler = (io) => {
 		const activeProcs = new Set();
 
 		socket.on('run-test', async (payload, legacyWorkers) => {
-			let tag, workers, browser, runners, testRunId;
+			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;
@@ -46,6 +50,8 @@ const socketHandler = (io) => {
 						? 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
@@ -63,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, testRunId);
+				runBuiltIn(
+					io,
+					socket,
+					activeProcs,
+					tag,
+					workers,
+					browser,
+					testRunId,
+					notifyDiscord,
+					notifySlack
+				);
 			} else {
-				runDistributed(io, socket, activeProcs, tag, workers, browser, runners, testRunId);
+				runDistributed(
+					io,
+					socket,
+					activeProcs,
+					tag,
+					workers,
+					browser,
+					runners,
+					testRunId,
+					notifyDiscord,
+					notifySlack
+				);
 			}
 		});
 
@@ -87,7 +114,17 @@ const socketHandler = (io) => {
 // Single built-in runner
 // ---------------------------------------------------------------------------
 
-function runBuiltIn(io, socket, activeProcs, tag, workers, browser, testRunId) {
+function runBuiltIn(
+	io,
+	socket,
+	activeProcs,
+	tag,
+	workers,
+	browser,
+	testRunId,
+	notifyDiscord,
+	notifySlack
+) {
 	const env = {
 		...process.env,
 		TAG: tag,
@@ -108,8 +145,30 @@ function runBuiltIn(io, socket, activeProcs, tag, workers, browser, testRunId) {
 		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}`));
+		}
 	});
 }
 
@@ -125,7 +184,9 @@ async function runDistributed(
 	workers,
 	browser,
 	runnerIds,
-	testRunId
+	testRunId,
+	notifyDiscord,
+	notifySlack
 ) {
 	const allIds = getTestIdsForTag(tag);
 	const chunks = chunkTests(allIds, runnerIds.length);
@@ -191,6 +252,21 @@ async function runDistributed(
 					// 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/frontend/src/lib/api/schedules.js

@@ -30,6 +30,8 @@ export async function saveCronJob({
 	workers,
 	browser,
 	runnerIds,
+	notifyDiscord,
+	notifySlack,
 	isEditing,
 	editTaskName
 }) {
@@ -47,7 +49,9 @@ export async function saveCronJob({
 			tags: formattedTags,
 			workers,
 			browser,
-			runnerIds
+			runnerIds,
+			notifyDiscord: notifyDiscord ?? false,
+			notifySlack: notifySlack ?? false
 		})
 	});
 	return res.json();

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

@@ -46,3 +46,18 @@ export async function importBackup(data) {
 	});
 	return res.json();
 }
+
+export async function fetchIntegrations() {
+	const res = await fetch(`${API_BASE}/settings/integrations`);
+	if (!res.ok) return { discordWebhookUrl: '', slackWebhookUrl: '', notifyPublicUrl: '' };
+	return res.json();
+}
+
+export async function saveIntegrations({ discordWebhookUrl, slackWebhookUrl, notifyPublicUrl }) {
+	const res = await fetch(`${API_BASE}/settings/integrations`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({ discordWebhookUrl, slackWebhookUrl, notifyPublicUrl })
+	});
+	return res.json();
+}

package/frontend/src/lib/components/layout/RunnerPanel.svelte

@@ -34,6 +34,7 @@
 	import { fetchLatestReportId, reportUrl } from '$lib/api/reports';
 	import { fetchRunners } from '$lib/api/runners';
 	import { fetchRuns, fetchRun } from '$lib/api/repository';
+	import { fetchIntegrations } from '$lib/api/settings';
 	import { API_BASE, BROWSERS } from '$lib/constants';
 	import ConfirmModal from '$lib/components/ui/ConfirmModal.svelte';
 
@@ -45,6 +46,9 @@
 	let runnersOpen = false;
 	let runPickOpen = false;
 	let runAllModalOpen = false;
+	let integrations = { discordWebhookUrl: '', slackWebhookUrl: '', notifyPublicUrl: '' };
+	let notifyDiscord = false;
+	let notifySlack = false;
 
 	function clickOutside(node) {
 		function handle(e) {
@@ -87,6 +91,10 @@
 			})
 			.catch(() => {});
 
+		fetchIntegrations()
+			.then((i) => (integrations = i))
+			.catch(() => {});
+
 		_unsubConfig = runnerConfig.subscribe((v) => {
 			try {
 				localStorage.setItem('plum:runnerConfig', JSON.stringify(v));
@@ -251,14 +259,15 @@
 	}
 
 	function handleRunClick() {
+		const notify = { notifyDiscord, notifySlack };
 		if (selectedRun) {
 			if (selectedRunLoading || !selectedRun.tags) return;
 			if (selectedRun.tags.length === 0) return;
-			triggerRun(selectedRun.tags.join(' or '), selectedRun.id);
+			triggerRun(selectedRun.tags.join(' or '), selectedRun.id, notify);
 		} else if ($runnerConfig.testID.trim() === '') {
 			runAllModalOpen = true;
 		} else {
-			triggerRun();
+			triggerRun(undefined, undefined, notify);
 		}
 	}
 
@@ -294,7 +303,7 @@
 	confirmLabel="Run all tests"
 	on:confirm={() => {
 		runAllModalOpen = false;
-		triggerRun();
+		triggerRun(undefined, undefined, { notifyDiscord, notifySlack });
 	}}
 >
 	No tag or filter is set. This will run <strong>every test</strong> in the suite, which may take a while.
@@ -586,6 +595,35 @@
 				</div>
 			{/if}
 
+			{#if integrations.discordWebhookUrl || integrations.slackWebhookUrl}
+				<div class="ctrl-divider"></div>
+				<div class="ctrl-group">
+					<span class="ctrl-label">Notify</span>
+					<div class="notify-toggles">
+						{#if integrations.discordWebhookUrl}
+							<button
+								type="button"
+								class="notify-btn"
+								class:active={notifyDiscord}
+								on:click={() => (notifyDiscord = !notifyDiscord)}
+								title={notifyDiscord ? 'Discord notification on' : 'Discord notification off'}
+								disabled={state.running}>Discord</button
+							>
+						{/if}
+						{#if integrations.slackWebhookUrl}
+							<button
+								type="button"
+								class="notify-btn"
+								class:active={notifySlack}
+								on:click={() => (notifySlack = !notifySlack)}
+								title={notifySlack ? 'Slack notification on' : 'Slack notification off'}
+								disabled={state.running}>Slack</button
+							>
+						{/if}
+					</div>
+				</div>
+			{/if}
+
 			<div class="ctrl-divider"></div>
 
 			<!-- Run button -->
@@ -1154,6 +1192,44 @@
 		}
 	}
 
+	/* Notification toggles */
+	.notify-toggles {
+		display: flex;
+		gap: 0.25rem;
+	}
+
+	.notify-btn {
+		height: 26px;
+		padding: 0 0.5rem;
+		border-radius: var(--radius-sm);
+		border: 1px solid var(--border);
+		background: transparent;
+		color: var(--text-muted);
+		font-size: 0.75rem;
+		font-family: inherit;
+		cursor: pointer;
+		transition:
+			background var(--duration-fast),
+			color var(--duration-fast),
+			border-color var(--duration-fast);
+	}
+
+	.notify-btn:hover:not(:disabled) {
+		color: var(--text);
+		border-color: var(--text-muted);
+	}
+
+	.notify-btn.active {
+		background: var(--accent);
+		border-color: var(--accent);
+		color: #fff;
+	}
+
+	.notify-btn:disabled {
+		opacity: 0.4;
+		cursor: default;
+	}
+
 	/* Expand button */
 	.expand-btn {
 		display: flex;