plum-e2e 2.1.0 → 2.3.0

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,77 @@ 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 ?? ''
+		}
+	});
+};
+
+const getBackupConfig = async () => {
+	const project = await getProject();
+	return {
+		backupEnabled: project.backupEnabled,
+		backupCron: project.backupCron,
+		backupS3Endpoint: project.backupS3Endpoint,
+		backupS3Region: project.backupS3Region,
+		backupS3Bucket: project.backupS3Bucket,
+		backupS3AccessKey: project.backupS3AccessKey,
+		backupS3SecretKeySet: project.backupS3SecretKey.length > 0,
+		backupS3Prefix: project.backupS3Prefix,
+		backupLastRunAt: project.backupLastRunAt,
+		backupLastStatus: project.backupLastStatus
+	};
+};
+
+const updateBackupConfig = async ({
+	backupEnabled,
+	backupCron,
+	backupS3Endpoint,
+	backupS3Region,
+	backupS3Bucket,
+	backupS3AccessKey,
+	backupS3SecretKey,
+	backupS3Prefix
+}) => {
+	const update = {
+		...(backupEnabled !== undefined && { backupEnabled }),
+		...(backupCron !== undefined && { backupCron }),
+		...(backupS3Endpoint !== undefined && { backupS3Endpoint }),
+		...(backupS3Region !== undefined && { backupS3Region }),
+		...(backupS3Bucket !== undefined && { backupS3Bucket }),
+		...(backupS3AccessKey !== undefined && { backupS3AccessKey }),
+		...(backupS3SecretKey && { backupS3SecretKey }),
+		...(backupS3Prefix !== undefined && { backupS3Prefix })
+	};
+	return prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1, ...update },
+		update
+	});
+};
+
+module.exports = {
+	getProject,
+	updateProject,
+	getTestPrefixes,
+	updateTestPrefixes,
+	getWebhooks,
+	updateWebhooks,
+	getBackupConfig,
+	updateBackupConfig
+};

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,59 @@ export async function importBackup(data) {
 	});
 	return res.json();
 }
+
+export async function fetchBackupConfig() {
+	const res = await fetch(`${API_BASE}/backup/config`);
+	if (!res.ok)
+		return {
+			backupEnabled: false,
+			backupCron: '0 2 * * *',
+			backupS3Endpoint: '',
+			backupS3Region: '',
+			backupS3Bucket: '',
+			backupS3AccessKey: '',
+			backupS3SecretKeySet: false,
+			backupS3Prefix: '',
+			backupLastRunAt: null,
+			backupLastStatus: ''
+		};
+	return res.json();
+}
+
+export async function saveBackupConfig(config) {
+	const res = await fetch(`${API_BASE}/backup/config`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(config)
+	});
+	return res.json();
+}
+
+export async function testBackupS3(config) {
+	const res = await fetch(`${API_BASE}/backup/test-s3`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(config)
+	});
+	return res.json();
+}
+
+export async function runBackupNow() {
+	const res = await fetch(`${API_BASE}/backup/run-now`, { method: 'POST' });
+	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;

package/frontend/src/lib/stores/runner.js

@@ -48,7 +48,7 @@ export const runsVersion = writable(0);
 // Map of taskName → true for every cron job currently executing
 export const activeCronJobs = writable({});
 
-export function triggerRun(id, testRunId) {
+export function triggerRun(id, testRunId, notify = {}) {
 	const s = get(socket);
 	if (!s) return;
 
@@ -72,7 +72,9 @@ export function triggerRun(id, testRunId) {
 		workers,
 		browser,
 		runners: selectedRunners,
-		testRunId: testRunId ?? null
+		testRunId: testRunId ?? null,
+		notifyDiscord: notify.notifyDiscord ?? false,
+		notifySlack: notify.notifySlack ?? false
 	});
 }