plum-e2e 2.1.0 → 2.3.0

package/backend/services/backupCronService.js

@@ -0,0 +1,82 @@
+/*
+ * 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 cron = require('node-cron');
+const prisma = require('./prisma');
+const backupService = require('./backupService');
+
+let scheduledJob = null;
+
+const runBackup = async () => {
+	let project;
+	try {
+		project = await prisma.project.findUnique({ where: { id: 1 } });
+	} catch (err) {
+		console.error('❌ Backup: could not read project config:', err.message);
+		return;
+	}
+
+	if (!project?.backupEnabled) return;
+
+	try {
+		const data = await backupService.exportAll();
+		const key = await backupService.uploadToS3(data, project);
+
+		await prisma.project.update({
+			where: { id: 1 },
+			data: {
+				backupLastRunAt: new Date(),
+				backupLastStatus: `success:${key}`
+			}
+		});
+		console.log(`✅ Backup uploaded: ${key}`);
+	} catch (err) {
+		console.error('❌ Backup failed:', err.message);
+		try {
+			await prisma.project.update({
+				where: { id: 1 },
+				data: {
+					backupLastRunAt: new Date(),
+					backupLastStatus: `error:${err.message}`
+				}
+			});
+		} catch {}
+	}
+};
+
+const schedule = (cronExpr, enabled) => {
+	if (scheduledJob) {
+		scheduledJob.stop();
+		scheduledJob = null;
+	}
+	if (!enabled || !cronExpr || !cron.validate(cronExpr)) return;
+	scheduledJob = cron.schedule(cronExpr, runBackup);
+	console.log(`⏰ Backup scheduled: ${cronExpr}`);
+};
+
+const init = async () => {
+	try {
+		const project = await prisma.project.findUnique({ where: { id: 1 } });
+		schedule(project?.backupCron, project?.backupEnabled);
+	} catch (err) {
+		console.error('Failed to initialize backup cron:', err.message);
+	}
+};
+
+const reload = init;
+
+module.exports = { init, reload, runBackup };

package/backend/services/backupService.js

@@ -17,45 +17,272 @@
 
 const prisma = require('./prisma');
 
+// ---------------------------------------------------------------------------
+// Export — all data except reports (reports are too large; use pg_dump instead)
+// ---------------------------------------------------------------------------
+
 const exportAll = async () => {
-	const [cronJobs, project] = await Promise.all([
+	const [cronJobs, project, testSuites, testRuns, users, runners] = await Promise.all([
 		prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } }),
-		prisma.project.findUnique({ where: { id: 1 } })
+		prisma.project.findUnique({ where: { id: 1 } }),
+		prisma.testSuite.findMany({
+			orderBy: { createdAt: 'asc' },
+			include: {
+				cases: {
+					include: { steps: { orderBy: { order: 'asc' } } },
+					orderBy: { createdAt: 'asc' }
+				}
+			}
+		}),
+		prisma.testRun.findMany({
+			orderBy: { createdAt: 'asc' },
+			include: { entries: { orderBy: { order: 'asc' } } }
+		}),
+		prisma.user.findMany({ orderBy: { createdAt: 'asc' } }),
+		prisma.runner.findMany({ orderBy: { createdAt: 'asc' } })
 	]);
 
 	return {
-		version: '1',
+		version: '2',
 		exportedAt: new Date().toISOString(),
-		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, ...r }) => r),
-		project: project ? { name: project.name, logoUrl: project.logoUrl } : null
+		disclaimer:
+			'Reports are not included in this backup. Use pg_dump on the PostgreSQL volume to back up report history.',
+		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, runnerId: __, ...r }) => r),
+		project: project
+			? {
+					name: project.name,
+					logoUrl: project.logoUrl,
+					testCasePrefix: project.testCasePrefix,
+					testSuitePrefix: project.testSuitePrefix,
+					discordWebhookUrl: project.discordWebhookUrl,
+					slackWebhookUrl: project.slackWebhookUrl,
+					notifyPublicUrl: project.notifyPublicUrl
+				}
+			: null,
+		users: users.map(({ updatedAt: _, ...u }) => u),
+		runners: runners.map(({ createdAt: _, cronJobs: __, reports: ___, ...r }) => r),
+		testSuites: testSuites.map(({ cases, ...suite }) => ({
+			...suite,
+			cases: cases.map(({ steps, runEntries: _, history: __, ...tc }) => ({
+				...tc,
+				steps: steps.map(({ createdAt: ___, ...step }) => step)
+			}))
+		})),
+		testRuns: testRuns.map(({ entries, history: _, ...run }) => ({
+			...run,
+			entries: entries.map(({ executedAt, ...entry }) => ({ ...entry, executedAt }))
+		}))
 	};
 };
 
-const importAll = async ({ cronJobs = [], project = null }, cronService) => {
-	await prisma.$transaction(async (tx) => {
-		for (const job of cronJobs) {
-			await tx.cronJob.upsert({
-				where: { taskName: job.taskName },
-				create: {
-					taskName: job.taskName,
-					cronExpression: job.cronExpression,
-					tags: job.tags,
-					workers: job.workers ?? 1
-				},
-				update: { cronExpression: job.cronExpression, tags: job.tags, workers: job.workers ?? 1 }
-			});
+// ---------------------------------------------------------------------------
+// Import — upsert all exported data, preserve IDs for relational integrity
+// ---------------------------------------------------------------------------
+
+const importAll = async (
+	{ cronJobs = [], project = null, users = [], runners = [], testSuites = [], testRuns = [] },
+	cronService
+) => {
+	await prisma.$transaction(
+		async (tx) => {
+			// 1. Users (needed before suites/runs reference createdById)
+			for (const user of users) {
+				await tx.user.upsert({
+					where: { email: user.email },
+					create: user,
+					update: { name: user.name, role: user.role }
+				});
+			}
+
+			// 2. Runners
+			for (const runner of runners) {
+				await tx.runner.upsert({
+					where: { id: runner.id },
+					create: runner,
+					update: {
+						name: runner.name,
+						url: runner.url,
+						token: runner.token,
+						browser: runner.browser
+					}
+				});
+			}
+
+			// 3. CronJobs
+			for (const job of cronJobs) {
+				await tx.cronJob.upsert({
+					where: { taskName: job.taskName },
+					create: {
+						taskName: job.taskName,
+						cronExpression: job.cronExpression,
+						tags: job.tags,
+						workers: job.workers ?? 1,
+						browser: job.browser ?? 'chromium',
+						enabled: job.enabled ?? true,
+						runnerIds: job.runnerIds ?? 'built-in',
+						notifyDiscord: job.notifyDiscord ?? false,
+						notifySlack: job.notifySlack ?? false
+					},
+					update: {
+						cronExpression: job.cronExpression,
+						tags: job.tags,
+						workers: job.workers ?? 1,
+						browser: job.browser ?? 'chromium',
+						runnerIds: job.runnerIds ?? 'built-in',
+						notifyDiscord: job.notifyDiscord ?? false,
+						notifySlack: job.notifySlack ?? false
+					}
+				});
+			}
+
+			// 4. Project settings
+			if (project) {
+				await tx.project.upsert({
+					where: { id: 1 },
+					create: { id: 1, ...project },
+					update: project
+				});
+			}
+
+			// 5. Test suites + cases + steps
+			for (const suite of testSuites) {
+				const { cases = [], ...suiteData } = suite;
+				await tx.testSuite.upsert({
+					where: { displayId: suiteData.displayId },
+					create: suiteData,
+					update: {
+						name: suiteData.name,
+						description: suiteData.description,
+						priority: suiteData.priority
+					}
+				});
+
+				for (const tc of cases) {
+					const { steps = [], ...caseData } = tc;
+					await tx.testCase.upsert({
+						where: { displayId: caseData.displayId },
+						create: caseData,
+						update: {
+							title: caseData.title,
+							description: caseData.description,
+							priority: caseData.priority,
+							isAutomated: caseData.isAutomated
+						}
+					});
+
+					// Replace all steps for this case (order may have changed)
+					await tx.testStep.deleteMany({ where: { caseId: caseData.id } });
+					for (const step of steps) {
+						await tx.testStep.create({ data: step });
+					}
+				}
+			}
+
+			// 6. Test runs + entries
+			for (const run of testRuns) {
+				const { entries = [], ...runData } = run;
+				await tx.testRun.upsert({
+					where: { id: runData.id },
+					create: runData,
+					update: { title: runData.title, status: runData.status }
+				});
+
+				for (const entry of entries) {
+					await tx.testRunEntry.upsert({
+						where: { id: entry.id },
+						create: entry,
+						update: { status: entry.status, notes: entry.notes, order: entry.order }
+					});
+				}
+			}
+		},
+		{ timeout: 30000 }
+	);
+
+	if (cronService) await cronService.reload();
+};
+
+// ---------------------------------------------------------------------------
+// S3 upload — S3-compatible object storage (AWS, R2, B2, MinIO)
+// ---------------------------------------------------------------------------
+
+const uploadToS3 = async (jsonData, config) => {
+	const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3');
+
+	const {
+		backupS3Endpoint,
+		backupS3Region,
+		backupS3Bucket,
+		backupS3AccessKey,
+		backupS3SecretKey,
+		backupS3Prefix
+	} = config;
+
+	const clientConfig = {
+		region: backupS3Region || 'auto',
+		credentials: {
+			accessKeyId: backupS3AccessKey,
+			secretAccessKey: backupS3SecretKey
 		}
+	};
+	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
+
+	const client = new S3Client(clientConfig);
+
+	const date = new Date().toISOString().slice(0, 10);
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
+	const key = `${prefix}plum-backup-${date}.json`;
+
+	await client.send(
+		new PutObjectCommand({
+			Bucket: backupS3Bucket,
+			Key: key,
+			Body: JSON.stringify(jsonData, null, 2),
+			ContentType: 'application/json'
+		})
+	);
+
+	return key;
+};
+
+const testS3Connection = async (config) => {
+	const { S3Client, PutObjectCommand, DeleteObjectCommand } = await import('@aws-sdk/client-s3');
 
-		if (project) {
-			await tx.project.upsert({
-				where: { id: 1 },
-				create: { id: 1, name: project.name ?? '', logoUrl: project.logoUrl ?? '' },
-				update: { name: project.name ?? '', logoUrl: project.logoUrl ?? '' }
-			});
+	const {
+		backupS3Endpoint,
+		backupS3Region,
+		backupS3Bucket,
+		backupS3AccessKey,
+		backupS3SecretKey,
+		backupS3Prefix
+	} = config;
+
+	const clientConfig = {
+		region: backupS3Region || 'auto',
+		credentials: {
+			accessKeyId: backupS3AccessKey,
+			secretAccessKey: backupS3SecretKey
 		}
-	});
+	};
+	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
 
-	if (cronService) await cronService.reload();
+	const client = new S3Client(clientConfig);
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
+	const key = `${prefix}.plum-connection-test`;
+
+	await client.send(
+		new PutObjectCommand({
+			Bucket: backupS3Bucket,
+			Key: key,
+			Body: 'ok',
+			ContentType: 'text/plain'
+		})
+	);
+
+	// Clean up the test file
+	try {
+		await client.send(new DeleteObjectCommand({ Bucket: backupS3Bucket, Key: key }));
+	} catch {}
 };
 
-module.exports = { exportAll, importAll };
+module.exports = { exportAll, importAll, uploadToS3, testS3Connection };

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