plum-e2e 1.2.4 → 1.3.0

package/backend/_scaffold/utils/browser.ts

@@ -1,4 +1,4 @@
-import { chromium, Browser, BrowserContext, Page } from 'playwright';
+import { chromium, firefox, webkit, Browser, BrowserContext, Page } from 'playwright';
 
 let _browser: Browser;
 let _context: BrowserContext;
@@ -8,7 +8,10 @@ export const page = (): Page => _page;
 
 export async function setup(): Promise<void> {
 	const isHeadless = process.env.IS_HEADLESS?.toLowerCase() !== 'false';
-	_browser = await chromium.launch({ headless: isHeadless });
+	const browserName = (process.env.BROWSER || 'chromium').toLowerCase();
+	const browserType =
+		browserName === 'firefox' ? firefox : browserName === 'webkit' ? webkit : chromium;
+	_browser = await browserType.launch({ headless: isHeadless });
 	_context = await _browser.newContext();
 	_page = await _context.newPage();
 }

package/backend/app.js

@@ -15,25 +15,33 @@
  * along with Plum. If not, see https://www.gnu.org/licenses/.
  */
 
+const path = require('path');
 const express = require('express');
 const cors = require('cors');
+const { SCREENSHOTS_DIR } = require('./lib/reportFilename');
 const app = express();
 
 app.use(cors({ origin: '*' }));
 app.use(express.json());
 
+// Serve screenshot files written during report processing
+app.use('/screenshots', express.static(SCREENSHOTS_DIR));
+
 // Routes
 const testRoutes = require('./routes/tests.routes');
 const reportRoutes = require('./routes/reports.routes');
 const cronRoutes = require('./routes/cron.routes');
 const settingsRoutes = require('./routes/settings.routes');
 const backupRoutes = require('./routes/backup.routes');
+const runnerRoutes = require('./routes/runners.routes');
+const nodeRoutes = require('./routes/node.routes');
 
 app.use('/tests', testRoutes);
 app.use('/reports', reportRoutes);
 app.use('/cron-jobs', cronRoutes);
-app.use('/reports', express.static('reports'));
 app.use('/settings', settingsRoutes);
 app.use('/backup', backupRoutes);
+app.use('/runners', runnerRoutes);
+app.use('/api', nodeRoutes);
 
 module.exports = app;

package/backend/config/scripts/generate-report.js

@@ -17,83 +17,44 @@
 
 const fs = require('fs');
 const path = require('path');
-const reportsDir = 'reports';
-const screenshotsDir = path.join(reportsDir, 'screenshots');
+const { normaliseTrigger } = require('../../constants/triggers');
+const { REPORTS_DIR } = require('../../lib/reportFilename');
 
-if (!fs.existsSync(reportsDir)) fs.mkdirSync(reportsDir, { recursive: true });
-if (!fs.existsSync(screenshotsDir)) fs.mkdirSync(screenshotsDir, { recursive: true });
+const jsonReportFile = path.join(REPORTS_DIR, 'cucumber_report.json');
 
-// Determine PASS/FAIL from cucumber JSON output
-const jsonReportFile = path.join(reportsDir, 'cucumber_report.json');
-let status = 'PASS';
+if (!fs.existsSync(jsonReportFile)) {
+	console.log('No cucumber_report.json found — skipping report save.');
+	process.exit(0);
+}
+
+// Remote runner nodes (PLUM_MODE=node) have no DB access.
+// The primary server reads cucumber_report.json via readCucumberReportFile()
+// and saves the combined report after all lanes finish.
+if (process.env.PLUM_MODE === 'node') process.exit(0);
 
-if (fs.existsSync(jsonReportFile)) {
+(async () => {
 	try {
-		const parsedData = JSON.parse(fs.readFileSync(jsonReportFile, 'utf8'));
-		const hasFailures = parsedData.some((feature) =>
-			feature.elements?.some((scenario) =>
-				scenario.steps?.some((step) => step.result?.status === 'failed')
-			)
+		const raw = JSON.parse(fs.readFileSync(jsonReportFile, 'utf8'));
+		const reportService = require('../../services/reportService');
+		const triggerType = normaliseTrigger(process.env.TRIGGER);
+		const rawTag = process.env.TAG || '@all-tests';
+		const nodeCount = Math.max(
+			1,
+			parseInt(process.env.REPORT_RUNNERS || process.env.PARALLEL || '1', 10) || 1
 		);
-		if (hasFailures) status = 'FAIL';
+
+		const saved = await reportService.saveReport({
+			rawCucumberJson: raw,
+			tags: rawTag,
+			triggerType,
+			nodeCount,
+			browser: process.env.BROWSER || 'chromium',
+			runnerName: process.env.RUNNER_NAME || null,
+			runnerId: process.env.RUNNER_ID || null
+		});
+
+		console.log(`Report saved to database (id: ${saved.id})`);
 	} catch (e) {
-		console.error('Could not parse cucumber_report.json:', e.message);
+		console.error('Could not save report to database:', e.message);
 	}
-} else {
-	console.log('No cucumber_report.json found.');
-}
-
-// Build filename with same convention as before, now .json
-let tag = process.env.TAG || '(@all-tests)';
-if (tag && !tag.startsWith('(')) tag = `(${tag})`;
-
-const timestamp = new Date().toISOString().replace(/[-:.]/g, '_');
-const runners = Number.parseInt(process.env.REPORT_RUNNERS || process.env.PARALLEL || '1', 10);
-const runnerCount = Number.isFinite(runners) && runners > 0 ? runners : 1;
-const reportFileName = `${status}_cucumber_report_${process.env.TRIGGER}_${tag}_runners_${runnerCount}_${timestamp}.json`;
-
-// Save a timestamped snapshot of the cucumber JSON
-if (fs.existsSync(jsonReportFile)) {
-	fs.copyFileSync(jsonReportFile, path.join(reportsDir, reportFileName));
-	console.log(`Report saved: ${reportFileName}`);
-
-	// Persist metadata to database
-	(async () => {
-		try {
-			const { PrismaClient } = require('@prisma/client');
-			const prisma = new PrismaClient();
-
-			const triggerType = process.env.TRIGGER || 'command-line-trigger';
-			const builtInTriggers = ['manual-trigger', 'command-line-trigger', 'undefined'];
-			let cronJobId = null;
-
-			if (!builtInTriggers.includes(triggerType)) {
-				const job = await prisma.cronJob.findUnique({ where: { taskName: triggerType } });
-				if (job) cronJobId = job.id;
-			}
-
-			const rawTag = process.env.TAG || '@all-tests';
-			const tags = rawTag.replace(/^\(|\)$/g, '');
-
-			await prisma.report.upsert({
-				where: { fileName: reportFileName },
-				create: {
-					fileName: reportFileName,
-					status,
-					tags,
-					triggerType,
-					runners: runnerCount,
-					cronJobId
-				},
-				update: {}
-			});
-
-			await prisma.$disconnect();
-			console.log('Report metadata saved to database.');
-		} catch (e) {
-			console.error('Could not save report metadata to DB:', e.message);
-		}
-	})();
-} else {
-	console.log('Skipping report save — no cucumber_report.json.');
-}
+})();

package/backend/config/scripts/run-tests.js

@@ -23,20 +23,24 @@ const parallel =
 	process.env.PARALLEL || (parallelIdx !== -1 ? process.argv[parallelIdx + 1] : null);
 const runners = parallel || process.env.REPORT_RUNNERS || '1';
 const tag = process.env.TAG || process.argv.slice(2).find((a) => a.startsWith('@'));
+const browser = process.env.BROWSER || 'chromium';
 
 try {
+	const testsRoot = (process.env.TESTS_ROOT || 'tests').replace(/\\/g, '/');
+
 	const baseCommand = [
 		'npx',
 		'cross-env',
+		`BROWSER=${browser}`,
 		'TS_NODE_TRANSPILE_ONLY=true',
 		'cucumber-js',
-		'tests/features/**/*.feature',
+		`${testsRoot}/features/**/*.feature`,
 		'--require-module',
 		'ts-node/register',
 		'--require',
-		'tests/utils/hooks.ts',
+		`${testsRoot}/utils/hooks.ts`,
 		'--require',
-		'tests/step_definitions/**/*.ts',
+		`${testsRoot}/step_definitions/**/*.ts`,
 		'--format',
 		'json:reports/cucumber_report.json'
 	];

package/backend/constants/triggers.js

@@ -0,0 +1,67 @@
+/*
+ * 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/.
+ */
+
+/**
+ * Authoritative trigger type values stored in Report.triggerType.
+ *
+ * Manual and CLI are the only fixed values.
+ * Scheduled runs store the cron job's taskName as the triggerType.
+ */
+const TRIGGER_TYPE = Object.freeze({
+	MANUAL: 'manual-trigger',
+	CLI: 'command-line-trigger'
+});
+
+/**
+ * Sentinel written into partial node-mode report filenames (never stored in main DB).
+ * Used by remote runner nodes and by the built-in lane when running as part of a
+ * distributed job (PLUM_MODE=node blocks the DB write in generate-report.js).
+ */
+const TRIGGER_REMOTE = 'remote-trigger';
+
+/** The string ID used throughout the codebase to refer to the built-in runner. */
+const BUILT_IN_RUNNER_ID = 'built-in';
+
+/**
+ * All trigger values that are NOT a cron task name.
+ * Anything outside this set is treated as a scheduled triggerType (i.e. the taskName).
+ */
+const NON_SCHEDULED_TRIGGERS = new Set([
+	TRIGGER_TYPE.MANUAL,
+	TRIGGER_TYPE.CLI,
+	TRIGGER_REMOTE,
+	'undefined'
+]);
+
+/** Returns true when triggerType is a cron job taskName (i.e. a scheduled run). */
+function isScheduledTrigger(triggerType) {
+	return !!triggerType && !NON_SCHEDULED_TRIGGERS.has(triggerType);
+}
+
+/** Normalises a raw TRIGGER env value for DB storage — falls back to CLI if blank. */
+function normaliseTrigger(raw) {
+	return raw || TRIGGER_TYPE.CLI;
+}
+
+module.exports = {
+	TRIGGER_TYPE,
+	TRIGGER_REMOTE,
+	BUILT_IN_RUNNER_ID,
+	NON_SCHEDULED_TRIGGERS,
+	isScheduledTrigger,
+	normaliseTrigger
+};

package/backend/lib/reportFilename.js

@@ -0,0 +1,37 @@
+/*
+ * 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 path = require('path');
+const fs = require('fs');
+
+const REPORTS_DIR = path.resolve(process.cwd(), 'reports');
+const SCREENSHOTS_DIR = path.join(REPORTS_DIR, 'screenshots');
+
+/**
+ * Reads the transient cucumber_report.json written by the most recent local test run.
+ * Returns the raw JSON string, or null if the file is absent or unreadable.
+ */
+function readCucumberReportFile() {
+	try {
+		const p = path.join(REPORTS_DIR, 'cucumber_report.json');
+		return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : null;
+	} catch {
+		return null;
+	}
+}
+
+module.exports = { REPORTS_DIR, SCREENSHOTS_DIR, readCucumberReportFile };

package/backend/lib/testChunker.js

@@ -0,0 +1,73 @@
+/*
+ * 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 { getTestSuites } = require('../services/testService');
+
+/**
+ * Returns the primary test ID for every test that matches the given tag.
+ * If tag is empty, all test IDs are returned.
+ *
+ * @param {string} tag  Cucumber tag expression (e.g. '@suite-login')
+ * @returns {string[]}
+ */
+function getTestIdsForTag(tag) {
+	const { suites } = getTestSuites();
+	const ids = [];
+	const normalTag = tag?.trim();
+
+	for (const suite of suites) {
+		const suiteIds = Array.isArray(suite.suiteId) ? suite.suiteId : [suite.suiteId];
+		const suiteMatches = !normalTag || suiteIds.some((id) => id === normalTag);
+
+		for (const test of suite.tests) {
+			const testIds = Array.isArray(test.id) ? test.id : [test.id];
+			if (suiteMatches || testIds.some((id) => id === normalTag)) {
+				ids.push(testIds[0]);
+			}
+		}
+	}
+
+	return ids;
+}
+
+/**
+ * Splits test IDs into N even chunks (one per runner slot).
+ * If n <= 1, returns a single chunk containing all IDs.
+ *
+ * @param {string[]} allIds
+ * @param {number} n  Number of chunks
+ * @returns {string[][]}
+ */
+function chunkTests(allIds, n) {
+	if (n <= 1) return [allIds];
+	const chunks = Array.from({ length: n }, () => []);
+	allIds.forEach((id, i) => chunks[i % n].push(id));
+	return chunks.filter((c) => c.length > 0);
+}
+
+/**
+ * Builds a Cucumber OR tag expression from an array of test IDs.
+ *
+ * @param {string[]} ids
+ * @returns {string}
+ */
+function buildTagExpression(ids) {
+	if (!ids || ids.length === 0) return '';
+	return ids.join(' or ');
+}
+
+module.exports = { getTestIdsForTag, chunkTests, buildTagExpression };

package/backend/middleware/auth.js

@@ -0,0 +1,32 @@
+/*
+ * 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/.
+ */
+
+/**
+ * Bearer-token auth guard for node-mode API routes.
+ * Passes through when NODE_TOKEN is not configured (open/dev environments).
+ */
+function authGuard(req, res, next) {
+	const nodeToken = process.env.NODE_TOKEN;
+	if (!nodeToken) return next();
+	const auth = req.headers.authorization;
+	if (!auth || auth !== `Bearer ${nodeToken}`) {
+		return res.status(401).json({ error: 'Unauthorized' });
+	}
+	next();
+}
+
+module.exports = { authGuard };

package/backend/package.json

@@ -1,12 +1,14 @@
 {
 	"name": "plum-backend",
-	"version": "1.2.1",
+	"version": "1.3.0",
 	"main": "index.js",
 	"scripts": {
 		"init": "node services/envService.js",
 		"create-step": "node config/scripts/create-step.mjs",
 		"create-env": "node services/envService.js",
-		"test": "node config/scripts/run-tests.js"
+		"test": "node config/scripts/run-tests.js",
+		"add-local-runner": "node scripts/add-local-runner.js",
+		"create-test": "node scripts/create-test.js"
 	},
 	"keywords": [],
 	"author": "",

package/backend/prisma/migrations/20260616000000_add_runners_and_browser/migration.sql

@@ -0,0 +1,26 @@
+-- CreateTable
+CREATE TABLE "Runner" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "url" TEXT NOT NULL,
+    "token" TEXT NOT NULL,
+    "browser" TEXT NOT NULL DEFAULT 'chromium',
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Runner_pkey" PRIMARY KEY ("id")
+);
+
+-- AlterTable
+ALTER TABLE "CronJob" ADD COLUMN "browser" TEXT NOT NULL DEFAULT 'chromium';
+ALTER TABLE "CronJob" ADD COLUMN "runnerId" TEXT;
+
+-- AlterTable
+ALTER TABLE "Report" ADD COLUMN "browser" TEXT NOT NULL DEFAULT 'chromium';
+ALTER TABLE "Report" ADD COLUMN "runnerId" TEXT;
+ALTER TABLE "Report" ADD COLUMN "runnerName" TEXT;
+
+-- AddForeignKey
+ALTER TABLE "CronJob" ADD CONSTRAINT "CronJob_runnerId_fkey" FOREIGN KEY ("runnerId") REFERENCES "Runner"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Report" ADD CONSTRAINT "Report_runnerId_fkey" FOREIGN KEY ("runnerId") REFERENCES "Runner"("id") ON DELETE SET NULL ON UPDATE CASCADE;

package/backend/prisma/migrations/20260616000001_cron_runner_ids/migration.sql

@@ -0,0 +1,6 @@
+-- Add runnerIds column to store multiple runner IDs as a comma-separated string.
+-- Existing jobs that already have a single runnerId are migrated to it;
+-- everything else defaults to 'built-in'.
+ALTER TABLE "CronJob" ADD COLUMN "runnerIds" TEXT NOT NULL DEFAULT 'built-in';
+
+UPDATE "CronJob" SET "runnerIds" = "runnerId" WHERE "runnerId" IS NOT NULL;

package/backend/prisma/migrations/20260617000000_cron_enabled/migration.sql

@@ -0,0 +1 @@
+ALTER TABLE "CronJob" ADD COLUMN "enabled" BOOLEAN NOT NULL DEFAULT true;

package/backend/prisma/migrations/20260617000001_report_content/migration.sql

@@ -0,0 +1,8 @@
+-- Clear all existing reports (no production data to preserve)
+TRUNCATE TABLE "Report" CASCADE;
+
+-- Drop the old filename-based column
+ALTER TABLE "Report" DROP COLUMN "fileName";
+
+-- Add the full report content as JSONB
+ALTER TABLE "Report" ADD COLUMN "content" JSONB NOT NULL DEFAULT '{}';

package/backend/prisma/schema.prisma

@@ -23,12 +23,28 @@ datasource db {
   url      = env("DATABASE_URL")
 }
 
+model Runner {
+  id        String    @id @default(cuid())
+  name      String
+  url       String
+  token     String
+  browser   String    @default("chromium")
+  createdAt DateTime  @default(now())
+  cronJobs  CronJob[]
+  reports   Report[]
+}
+
 model CronJob {
   id             Int      @id @default(autoincrement())
   taskName       String   @unique
   cronExpression String
   tags           String
   workers        Int      @default(1)
+  browser        String   @default("chromium")
+  enabled        Boolean  @default(true)
+  runnerId       String?
+  runnerIds      String   @default("built-in")
+  runner         Runner?  @relation(fields: [runnerId], references: [id], onDelete: SetNull)
   createdAt      DateTime @default(now())
   updatedAt      DateTime @updatedAt
   reports        Report[]
@@ -36,13 +52,17 @@ model CronJob {
 
 model Report {
   id          Int      @id @default(autoincrement())
-  fileName    String   @unique
   status      String
   tags        String
   triggerType String   @default("manual-trigger")
   runners     Int      @default(1)
+  browser     String   @default("chromium")
+  runnerName  String?
+  runnerId    String?
+  runner      Runner?  @relation(fields: [runnerId], references: [id], onDelete: SetNull)
   cronJobId   Int?
   cronJob     CronJob? @relation(fields: [cronJobId], references: [id], onDelete: SetNull)
+  content     Json
   createdAt   DateTime @default(now())
 }
 

package/backend/routes/cron.routes.js

@@ -62,6 +62,34 @@ router.put('/:taskName', async (req, res) => {
 	}
 });
 
+router.patch('/:taskName/toggle', async (req, res) => {
+	try {
+		const { taskName } = req.params;
+		const { enabled } = req.body;
+		if (typeof enabled !== 'boolean') {
+			return res.status(400).json({ error: 'enabled must be a boolean' });
+		}
+		const result = await cronService.toggleCronJob(taskName, enabled);
+		if (result.status === 404) return res.status(404).json({ error: result.message });
+		res.json({ taskName, enabled: result.enabled });
+	} catch (error) {
+		console.error('Error toggling cron job:', error);
+		res.status(500).json({ error: 'Failed to toggle cron job' });
+	}
+});
+
+router.post('/:taskName/run', async (req, res) => {
+	try {
+		const { taskName } = req.params;
+		const result = await cronService.runJobNow(taskName);
+		if (result.status === 404) return res.status(404).json({ error: result.message });
+		res.json({ message: `Cron job ${taskName} triggered` });
+	} catch (error) {
+		console.error('Error running cron job:', error);
+		res.status(500).json({ error: 'Failed to run cron job' });
+	}
+});
+
 router.delete('/:taskName', async (req, res) => {
 	try {
 		const { taskName } = req.params;