plum-e2e 1.3.6 → 2.1.0

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/runnerService.js

@@ -28,7 +28,22 @@ const getAll = () => prisma.runner.findMany({ orderBy: { createdAt: 'asc' } });
 const create = ({ name, url, token, browser = 'chromium' }) =>
 	prisma.runner.create({ data: { name, url, token, browser } });
 
-const remove = (id) => prisma.runner.delete({ where: { id } });
+async function remove(id) {
+	// Scrub the deleted runner from any cron job's runnerIds string before
+	// deleting, since that field has no relational constraint.
+	const jobs = await prisma.cronJob.findMany({ select: { id: true, runnerIds: true } });
+	for (const job of jobs) {
+		const ids = job.runnerIds
+			.split(',')
+			.map((s) => s.trim())
+			.filter((s) => s && s !== id);
+		await prisma.cronJob.update({
+			where: { id: job.id },
+			data: { runnerIds: ids.length > 0 ? ids.join(',') : 'built-in' }
+		});
+	}
+	return prisma.runner.delete({ where: { id } });
+}
 
 const update = (id, data) => prisma.runner.update({ where: { id }, data });
 

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,20 @@ 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 })
+		}
+	});
+};
+
+module.exports = { getProject, updateProject, getTestPrefixes, updateTestPrefixes };

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