plum-e2e 1.3.7 → 2.2.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/reportService.js

@@ -22,6 +22,85 @@ const prisma = require('./prisma');
 const { isScheduledTrigger, normaliseTrigger } = require('../constants/triggers');
 const { SCREENSHOTS_DIR } = require('../lib/reportFilename');
 
+// ---------------------------------------------------------------------------
+// Auto-sync: mark test cases as automated and record history from Cucumber tags
+// ---------------------------------------------------------------------------
+
+async function syncAutomatedTags(reportId, features, testRunId = null) {
+	try {
+		const tagSet = new Set();
+		for (const feature of features) {
+			for (const scenario of feature.scenarios ?? []) {
+				for (const tag of scenario.tags ?? []) {
+					tagSet.add(tag.replace(/^@/, ''));
+				}
+			}
+		}
+		if (tagSet.size === 0) return;
+
+		const matchingCases = await prisma.testCase.findMany({
+			where: { displayId: { in: [...tagSet] } },
+			select: { id: true, displayId: true }
+		});
+		if (matchingCases.length === 0) return;
+
+		const tagToResult = new Map();
+		for (const feature of features) {
+			for (const scenario of feature.scenarios ?? []) {
+				for (const tag of scenario.tags ?? []) {
+					const t = tag.replace(/^@/, '');
+					const result = scenario.status === 'passed' ? 'pass' : 'fail';
+					if (!tagToResult.has(t) || result === 'fail') {
+						tagToResult.set(t, result);
+					}
+				}
+			}
+		}
+
+		await prisma.$transaction([
+			...matchingCases.map((tc) =>
+				prisma.testCase.update({ where: { id: tc.id }, data: { isAutomated: true } })
+			),
+			...matchingCases.map((tc) =>
+				prisma.testCaseHistory.create({
+					data: {
+						caseId: tc.id,
+						reportId,
+						result: tagToResult.get(tc.displayId) ?? 'pass',
+						source: 'automated'
+					}
+				})
+			)
+		]);
+
+		if (testRunId) {
+			const entries = await prisma.testRunEntry.findMany({
+				where: { runId: testRunId, case: { displayId: { in: [...tagToResult.keys()] } } },
+				select: { id: true, case: { select: { displayId: true } } }
+			});
+			if (entries.length > 0) {
+				await prisma.$transaction([
+					...entries.map((e) =>
+						prisma.testRunEntry.update({
+							where: { id: e.id },
+							data: {
+								status: tagToResult.get(e.case.displayId) ?? 'pass',
+								executedAt: new Date()
+							}
+						})
+					),
+					prisma.testRun.updateMany({
+						where: { id: testRunId, status: { in: ['backlog', 'draft'] } },
+						data: { status: 'in-progress' }
+					})
+				]);
+			}
+		}
+	} catch (e) {
+		console.error('[sync] Failed to sync automated tags:', e.message);
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -207,6 +286,7 @@ const getReportDetail = async (id) => {
  *   browser?: string,
  *   runnerName?: string,
  *   runnerId?: string,
+ *   testRunId?: string,
  * }} opts
  */
 const saveReport = async ({
@@ -216,13 +296,14 @@ const saveReport = async ({
 	nodeCount,
 	browser,
 	runnerName,
-	runnerId
+	runnerId,
+	testRunId
 }) => {
 	const normTrigger = normaliseTrigger(triggerType);
 	const { features, status } = processCucumberJson(rawCucumberJson);
 	const cronJobId = await resolveCronJobId(normTrigger);
 
-	return prisma.report.create({
+	const report = await prisma.report.create({
 		data: {
 			status,
 			tags: (tags ?? '').replace(/^\(|\)$/g, '') || '@all-tests',
@@ -235,6 +316,8 @@ const saveReport = async ({
 			content: { features }
 		}
 	});
+	syncAutomatedTags(report.id, features, testRunId ?? null);
+	return report;
 };
 
 /**
@@ -250,7 +333,15 @@ const saveReport = async ({
  *   browser: string,
  * }} opts
  */
-const saveCombinedReport = async ({ reports, runners, overallCode, tag, triggerType, browser }) => {
+const saveCombinedReport = async ({
+	reports,
+	runners,
+	overallCode,
+	tag,
+	triggerType,
+	browser,
+	testRunId
+}) => {
 	const featureMap = new Map();
 	for (const content of reports) {
 		if (!content) continue;
@@ -282,7 +373,8 @@ const saveCombinedReport = async ({ reports, runners, overallCode, tag, triggerT
 		nodeCount: runners.length,
 		browser,
 		runnerName: runners.map((r) => r.name).join(', '),
-		runnerId: null
+		runnerId: null,
+		testRunId: testRunId ?? null
 	});
 };
 

package/backend/services/settingsService.js

@@ -20,7 +20,7 @@ const prisma = require('./prisma');
 const getProject = async () => {
 	let project = await prisma.project.findUnique({ where: { id: 1 } });
 	if (!project) {
-		project = await prisma.project.create({ data: { id: 1, name: '', logoUrl: '' } });
+		project = await prisma.project.create({ data: { id: 1 } });
 	}
 	return project;
 };
@@ -33,4 +33,48 @@ const updateProject = async ({ name, logoUrl }) => {
 	});
 };
 
-module.exports = { getProject, updateProject };
+const getTestPrefixes = async () => {
+	const project = await getProject();
+	return { testCasePrefix: project.testCasePrefix, testSuitePrefix: project.testSuitePrefix };
+};
+
+const updateTestPrefixes = async ({ testCasePrefix, testSuitePrefix }) => {
+	return prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1 },
+		update: {
+			...(testCasePrefix !== undefined && { testCasePrefix }),
+			...(testSuitePrefix !== undefined && { testSuitePrefix })
+		}
+	});
+};
+
+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/services/testCaseService.js

@@ -0,0 +1,139 @@
+/*
+ * 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 caseSelect = {
+	id: true,
+	displayId: true,
+	title: true,
+	description: true,
+	priority: true,
+	isAutomated: true,
+	suiteId: true,
+	createdAt: true,
+	updatedAt: true,
+	createdBy: { select: { id: true, name: true } },
+	suite: { select: { id: true, displayId: true, name: true } },
+	_count: { select: { steps: true } }
+};
+
+async function getById(id) {
+	return prisma.testCase.findUnique({
+		where: { id },
+		select: {
+			...caseSelect,
+			steps: {
+				orderBy: { order: 'asc' }
+			},
+			history: {
+				select: {
+					id: true,
+					result: true,
+					source: true,
+					notes: true,
+					executedAt: true,
+					executedBy: { select: { id: true, name: true } },
+					run: { select: { id: true, title: true } },
+					report: { select: { id: true, status: true, createdAt: true } }
+				},
+				orderBy: { executedAt: 'desc' },
+				take: 50
+			}
+		}
+	});
+}
+
+async function create({ suiteId, title, description, priority, createdById }) {
+	const project = await prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1, caseSeqNext: 1 },
+		update: { caseSeqNext: { increment: 1 } },
+		select: { caseSeqNext: true, testCasePrefix: true }
+	});
+	const num = String(project.caseSeqNext).padStart(3, '0');
+	const displayId = `${project.testCasePrefix}-${num}`;
+
+	return prisma.testCase.create({
+		data: {
+			displayId,
+			suiteId,
+			title,
+			description: description ?? '',
+			priority: priority ?? 'Medium',
+			createdById
+		},
+		select: caseSelect
+	});
+}
+
+async function update(id, { title, description, priority }) {
+	return prisma.testCase.update({
+		where: { id },
+		data: {
+			...(title !== undefined && { title }),
+			...(description !== undefined && { description }),
+			...(priority !== undefined && { priority })
+		},
+		select: caseSelect
+	});
+}
+
+async function remove(id) {
+	return prisma.testCase.delete({ where: { id } });
+}
+
+async function upsertSteps(caseId, steps) {
+	await prisma.testStep.deleteMany({ where: { caseId } });
+	if (!steps || steps.length === 0) return [];
+	return prisma.$transaction(
+		steps.map((step, i) =>
+			prisma.testStep.create({
+				data: {
+					caseId,
+					action: step.action ?? '',
+					testData: step.testData ?? '',
+					expectedOutput: step.expectedOutput ?? '',
+					order: i
+				}
+			})
+		)
+	);
+}
+
+async function migratePrefix(newPrefix) {
+	const cases = await prisma.testCase.findMany({
+		select: { id: true, displayId: true },
+		orderBy: { createdAt: 'asc' }
+	});
+	const project = await prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1 },
+		update: { testCasePrefix: newPrefix },
+		select: { testCasePrefix: true }
+	});
+	for (let i = 0; i < cases.length; i++) {
+		const num = String(i + 1).padStart(3, '0');
+		await prisma.testCase.update({
+			where: { id: cases[i].id },
+			data: { displayId: `${newPrefix}-${num}` }
+		});
+	}
+	return project;
+}
+
+module.exports = { getById, create, update, remove, upsertSteps, migratePrefix };

package/backend/services/testRunService.js

@@ -0,0 +1,203 @@
+/*
+ * 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 runListSelect = {
+	id: true,
+	title: true,
+	status: true,
+	createdAt: true,
+	updatedAt: true,
+	createdBy: { select: { id: true, name: true } },
+	_count: { select: { entries: true } }
+};
+
+function runOrderBy(sortBy, sortOrder) {
+	const dir = sortOrder === 'desc' ? 'desc' : 'asc';
+	if (sortBy === 'title') return { title: dir };
+	if (sortBy === 'status') return { status: dir };
+	if (sortBy === 'updatedAt') return { updatedAt: dir };
+	return { createdAt: dir };
+}
+
+async function getAll({ page = 1, limit = 20, q, sortBy = 'createdAt', sortOrder = 'desc' } = {}) {
+	const skip = (page - 1) * limit;
+	const where = q ? { title: { contains: q, mode: 'insensitive' } } : {};
+	const orderBy = runOrderBy(sortBy, sortOrder);
+	const [runs, total] = await Promise.all([
+		prisma.testRun.findMany({ where, select: runListSelect, orderBy, skip, take: limit }),
+		prisma.testRun.count({ where })
+	]);
+	return { runs, total };
+}
+
+async function getById(id) {
+	return prisma.testRun.findUnique({
+		where: { id },
+		select: {
+			id: true,
+			title: true,
+			status: true,
+			createdAt: true,
+			updatedAt: true,
+			createdBy: { select: { id: true, name: true } },
+			entries: {
+				select: {
+					id: true,
+					order: true,
+					status: true,
+					notes: true,
+					executedAt: true,
+					executedBy: { select: { id: true, name: true } },
+					assignedToId: true,
+					assignedTo: { select: { id: true, name: true } },
+					case: {
+						select: {
+							id: true,
+							displayId: true,
+							title: true,
+							priority: true,
+							isAutomated: true,
+							suite: { select: { id: true, name: true, displayId: true } },
+							steps: { orderBy: { order: 'asc' } }
+						}
+					}
+				},
+				orderBy: { order: 'asc' }
+			}
+		}
+	});
+}
+
+async function create({ title, caseIds, createdById }) {
+	const run = await prisma.testRun.create({
+		data: {
+			title,
+			status: 'backlog',
+			createdById,
+			entries: {
+				create: (caseIds ?? []).map((caseId, i) => ({ caseId, order: i }))
+			}
+		},
+		select: runListSelect
+	});
+	return run;
+}
+
+async function update(id, { title, status, caseIds }) {
+	const data = {};
+	if (title !== undefined) data.title = title;
+	if (status !== undefined) data.status = status;
+
+	if (caseIds !== undefined) {
+		await prisma.testRunEntry.deleteMany({ where: { runId: id } });
+		await prisma.$transaction(
+			caseIds.map((caseId, i) =>
+				prisma.testRunEntry.create({ data: { runId: id, caseId, order: i } })
+			)
+		);
+	}
+
+	return prisma.testRun.update({ where: { id }, data, select: runListSelect });
+}
+
+async function duplicate(id, { createdById }) {
+	const original = await prisma.testRun.findUnique({
+		where: { id },
+		select: {
+			title: true,
+			entries: { select: { caseId: true, order: true }, orderBy: { order: 'asc' } }
+		}
+	});
+	if (!original) return null;
+	return prisma.testRun.create({
+		data: {
+			title: `Copy of ${original.title}`,
+			createdById,
+			entries: { create: original.entries.map((e, i) => ({ caseId: e.caseId, order: i })) }
+		},
+		select: runListSelect
+	});
+}
+
+async function remove(id) {
+	return prisma.testRun.delete({ where: { id } });
+}
+
+async function updateEntry(entryId, { status, notes, executedById }) {
+	const entry = await prisma.testRunEntry.update({
+		where: { id: entryId },
+		data: {
+			status,
+			notes: notes ?? '',
+			executedById: executedById ?? null,
+			executedAt: new Date()
+		},
+		select: {
+			id: true,
+			status: true,
+			notes: true,
+			executedAt: true,
+			runId: true,
+			caseId: true
+		}
+	});
+
+	if (status === 'pass' || status === 'fail' || status === 'blocked' || status === 'skip') {
+		await prisma.testCaseHistory.create({
+			data: {
+				caseId: entry.caseId,
+				runId: entry.runId,
+				result: status,
+				source: 'manual',
+				notes: notes ?? '',
+				executedById: executedById ?? null
+			}
+		});
+	}
+
+	return entry;
+}
+
+async function assignEntry(entryId, { userId }) {
+	return prisma.testRunEntry.update({
+		where: { id: entryId },
+		data: { assignedToId: userId ?? null },
+		select: { id: true, assignedToId: true, assignedTo: { select: { id: true, name: true } } }
+	});
+}
+
+async function reorderEntries(runId, orderedEntryIds) {
+	await prisma.$transaction(
+		orderedEntryIds.map((entryId, i) =>
+			prisma.testRunEntry.update({ where: { id: entryId }, data: { order: i } })
+		)
+	);
+}
+
+module.exports = {
+	getAll,
+	getById,
+	create,
+	update,
+	duplicate,
+	remove,
+	updateEntry,
+	assignEntry,
+	reorderEntries
+};