plum-e2e 2.9.17 → 2.12.0

package/backend/services/runnerService.js

@@ -201,10 +201,11 @@ async function fetchReportContent(runner, jobId, onLog) {
  */
 async function dispatchAndPoll(
 	runnerId,
-	{ tags, browser, workers },
+	{ tags, browser, workers, baseUrl },
 	onLog,
 	onDone,
-	onRRwebBatch = null
+	onRRwebBatch = null,
+	onJobId = null
 ) {
 	// The async poll callback can overlap if a tick takes longer than the interval;
 	// guard so the run resolves exactly once and can't be finalised while a lane
@@ -236,7 +237,7 @@ async function dispatchAndPoll(
 				browser,
 				workers,
 				tests: collectTestFiles(),
-				env: loadTestEnv(process.cwd())
+				env: { ...loadTestEnv(process.cwd()), ...(baseUrl ? { BASE_URL: baseUrl } : {}) }
 			}),
 			signal: AbortSignal.timeout(10000)
 		});
@@ -248,6 +249,7 @@ async function dispatchAndPoll(
 		return;
 	}
 
+	onJobId?.(jobId);
 	onLog(`Connected to runner "${runner.name}" — job ${jobId}\n`);
 
 	let logOffset = 0;
@@ -289,6 +291,21 @@ async function dispatchAndPoll(
 	}, 1000);
 }
 
+// Best-effort remote cancel — tells the node to SIGTERM the job's test process.
+// The polling loop in dispatchAndPoll still finalises the lane when the node
+// reports the job done/errored, so a failed cancel here is not fatal.
+async function cancelRemoteJob(runnerId, jobId) {
+	const runner = await getById(runnerId);
+	if (!runner) return;
+	try {
+		await fetch(`${runner.url}/api/cancel/${jobId}`, {
+			method: 'POST',
+			headers: bearerHeader(runner.token),
+			signal: AbortSignal.timeout(8000)
+		});
+	} catch {}
+}
+
 module.exports = {
 	getAll,
 	create,
@@ -300,5 +317,6 @@ module.exports = {
 	ping,
 	stop,
 	restart,
-	dispatchAndPoll
+	dispatchAndPoll,
+	cancelRemoteJob
 };

package/backend/services/testImportService.js

@@ -0,0 +1,87 @@
+/*
+ * This file is part of Plum.
+ * Licensed under the MIT License. See LICENSE file in the project root for details.
+ */
+
+const prisma = require('./prisma');
+const testCaseService = require('./testCaseService');
+const testSuiteService = require('./testSuiteService');
+
+// "TC-014" → "TC", "MY-TEAM-3" → "MY-TEAM", "loose" → "loose"
+const prefixOf = (displayId) => String(displayId ?? '').replace(/-\d+$/, '');
+
+async function importTestCases(payload, userId) {
+	if (!payload || payload.plumExport !== 'test-cases' || !Array.isArray(payload.suites)) {
+		const err = new Error('Not a Plum test-case export file.');
+		err.status = 400;
+		throw err;
+	}
+
+	const project = await prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1 },
+		update: {},
+		select: { testCasePrefix: true, testSuitePrefix: true }
+	});
+
+	const result = { importedSuites: 0, importedCases: 0, skippedSuites: 0, skippedCases: 0 };
+
+	for (const suite of payload.suites) {
+		if (!suite || typeof suite.name !== 'string' || !suite.name.trim()) {
+			result.skippedSuites += 1;
+			continue;
+		}
+
+		let suiteId;
+		const suiteCollides =
+			suite.displayId &&
+			prefixOf(suite.displayId) === project.testSuitePrefix &&
+			(await prisma.testSuite.findUnique({ where: { displayId: suite.displayId } }));
+
+		if (suiteCollides) {
+			suiteId = suiteCollides.id;
+			result.skippedSuites += 1;
+		} else {
+			const created = await testSuiteService.create({
+				name: suite.name.trim(),
+				description: suite.description ?? '',
+				priority: suite.priority ?? 'Medium',
+				createdById: userId
+			});
+			suiteId = created.id;
+			result.importedSuites += 1;
+		}
+
+		for (const c of suite.cases ?? []) {
+			if (!c || typeof c.title !== 'string' || !c.title.trim()) {
+				result.skippedCases += 1;
+				continue;
+			}
+
+			const caseCollides =
+				c.displayId &&
+				prefixOf(c.displayId) === project.testCasePrefix &&
+				(await prisma.testCase.findUnique({ where: { displayId: c.displayId } }));
+			if (caseCollides) {
+				result.skippedCases += 1;
+				continue;
+			}
+
+			const created = await testCaseService.create({
+				suiteId,
+				title: c.title.trim(),
+				description: c.description ?? '',
+				priority: c.priority ?? 'Medium',
+				createdById: userId
+			});
+			if (Array.isArray(c.steps) && c.steps.length > 0) {
+				await testCaseService.upsertSteps(created.id, c.steps);
+			}
+			result.importedCases += 1;
+		}
+	}
+
+	return result;
+}
+
+module.exports = { importTestCases };

package/backend/services/triggerService.js

@@ -3,197 +3,12 @@
  * Licensed under the MIT License. See LICENSE file in the project root for details.
  */
 
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const { spawn } = require('child_process');
-const { randomUUID } = require('crypto');
-const { startRRwebPoller } = require('../lib/rrwebPoller');
+const runQueueService = require('./runQueueService');
 const { TRIGGER_TYPE, BUILT_IN_RUNNER_ID } = require('../constants/triggers');
 const { DEFAULT_BROWSER } = require('../constants/defaults');
-const { PLUM_MODE_NODE } = require('../constants/env');
-const { SOCKET_EVENTS } = require('../constants/socketEvents');
-const { JOB_STATUS } = require('../constants/jobStatus');
-const { readCucumberReportFile } = require('../lib/reportFilename');
-const { runWithRetries } = require('../lib/retryRunner');
-const settingsService = require('./settingsService');
-const reportService = require('./reportService');
-const activeRunsService = require('./activeRunsService');
 
-const BACKEND_DIR = path.resolve(__dirname, '..');
-const JOB_TTL_MS = 60 * 60 * 1000; // 1 hour
-
-// In-memory job store: jobId → { status, exitCode, reportId, startedAt }
-const jobs = new Map();
-
-let _io = null;
-function setSocketIO(io) {
-	_io = io;
-}
-
-function pruneOldJobs() {
-	const cutoff = Date.now() - JOB_TTL_MS;
-	for (const [id, job] of jobs) {
-		if (job.startedAt < cutoff) jobs.delete(id);
-	}
-}
-
-function getJob(jobId) {
-	return jobs.get(jobId);
-}
-
-function runAttempt({
-	jobId,
-	tag,
-	browser,
-	workers,
-	trigger,
-	testRunId,
-	baseUrl,
-	suppressSave,
-	onLog,
-	onRRwebBatch
-}) {
-	return new Promise((resolve) => {
-		const ssDir = path.join(os.tmpdir(), `plum-trigger-ss-${jobId}-${Date.now()}`);
-		fs.mkdirSync(ssDir, { recursive: true });
-
-		const env = {
-			...process.env,
-			TAG: tag,
-			TRIGGER: trigger,
-			BROWSER: browser,
-			REPORT_RUNNERS: String(workers),
-			PLUM_SS_DIR: ssDir
-		};
-		if (Number(workers) > 1) env.PARALLEL = String(workers);
-		if (testRunId) env.TEST_RUN_ID = testRunId;
-		if (baseUrl) env.BASE_URL = baseUrl;
-		if (suppressSave) env.PLUM_MODE = PLUM_MODE_NODE;
-
-		const proc = spawn('npm', ['run', 'test'], { env, shell: true, cwd: BACKEND_DIR });
-
-		const ssPoller = startRRwebPoller(ssDir, onRRwebBatch);
-
-		proc.stdout.on('data', (d) => onLog(d.toString()));
-		proc.stderr.on('data', (d) => onLog(`[ERROR] ${d.toString()}`));
-
-		proc.on('close', (code) => {
-			ssPoller.stop();
-			fs.rm(ssDir, { recursive: true, force: true }, () => {});
-			resolve({ code, raw: suppressSave ? readCucumberReportFile() : null });
-		});
-	});
-}
-
-function runNoRetry({
-	jobId,
-	tag,
-	browser,
-	workers,
-	trigger,
-	testRunId,
-	baseUrl,
-	startedAt,
-	onLog,
-	onRRwebBatch
-}) {
-	runAttempt({
-		jobId,
-		tag,
-		browser,
-		workers,
-		trigger,
-		testRunId,
-		baseUrl,
-		suppressSave: false,
-		onLog,
-		onRRwebBatch
-	}).then(async ({ code }) => {
-		let reportId = null;
-		try {
-			const report = await reportService.attachDurationToLatestReport({
-				afterTimestamp: startedAt,
-				duration: Date.now() - startedAt
-			});
-			reportId = report?.id ?? null;
-			jobs.set(jobId, {
-				status: code === 130 ? JOB_STATUS.CANCELLED : JOB_STATUS.DONE,
-				exitCode: code,
-				reportId,
-				startedAt
-			});
-		} catch {
-			jobs.set(jobId, { status: JOB_STATUS.DONE, exitCode: code, reportId: null, startedAt });
-		}
-		activeRunsService.unregisterRun(jobId);
-		if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_DONE, { runId: jobId, code, reportId });
-	});
-}
-
-function runWithRetriesAndSave({
-	jobId,
-	tag,
-	browser,
-	workers,
-	trigger,
-	testRunId,
-	baseUrl,
-	maxRetries,
-	startedAt,
-	onLog,
-	onRRwebBatch
-}) {
-	runWithRetries({
-		maxRetries,
-		spawnAttempt: async (tagOverride) => {
-			const { code, raw } = await runAttempt({
-				jobId,
-				tag: tagOverride ?? tag,
-				browser,
-				workers,
-				trigger,
-				testRunId,
-				baseUrl,
-				suppressSave: true,
-				onLog,
-				onRRwebBatch
-			});
-			return { code, rawJson: raw ? JSON.parse(raw) : [] };
-		},
-		onLog
-	}).then(async ({ code, rawJson, attempts }) => {
-		let reportId = null;
-		try {
-			const report = await reportService.saveReport({
-				rawCucumberJson: rawJson,
-				tags: tag,
-				triggerType: trigger,
-				workerCount: workers,
-				browser,
-				testRunId: testRunId ?? null,
-				duration: Date.now() - startedAt,
-				attempts
-			});
-			reportId = report.id;
-			jobs.set(jobId, {
-				status: code === 130 ? JOB_STATUS.CANCELLED : JOB_STATUS.DONE,
-				exitCode: code,
-				reportId,
-				startedAt
-			});
-		} catch {
-			jobs.set(jobId, { status: JOB_STATUS.DONE, exitCode: code, reportId: null, startedAt });
-		}
-		activeRunsService.unregisterRun(jobId);
-		if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_DONE, { runId: jobId, code, reportId });
-	});
-}
-
-// Starts a background test run for the HTTP trigger API and returns the jobId
-// immediately — the run continues asynchronously, reporting progress via
-// socket.io events (bg-run-start/log/done) and the job store (polled through
-// getJob).
+// The REST/MCP trigger API is a thin front door onto the run queue. `getJob`
+// keeps the old poll shape so GET /trigger/:jobId callers don't have to change.
 async function startRun({
 	tag = '',
 	browser = DEFAULT_BROWSER,
@@ -202,52 +17,19 @@ async function startRun({
 	testRunId,
 	trigger
 }) {
-	pruneOldJobs();
-	const { maxRetries } = await settingsService.getProject();
-
-	const jobId = randomUUID();
-	const startedAt = Date.now();
-	jobs.set(jobId, { status: JOB_STATUS.RUNNING, exitCode: null, reportId: null, startedAt });
-
-	const label = trigger === TRIGGER_TYPE.MCP ? 'MCP run' : 'External run';
-	const meta = { tag, browser, workers };
-	activeRunsService.registerRun(jobId, { kind: trigger, label, meta });
-	if (_io) {
-		_io.emit(SOCKET_EVENTS.BG_RUN_START, { runId: jobId, kind: trigger, label, meta });
-	}
-
-	const onLog = (text) => {
-		if (_io) _io.emit(SOCKET_EVENTS.BG_RUN_LOG, { runId: jobId, log: text });
-	};
-	const onRRwebBatch = (batch) => {
-		if (_io) {
-			_io.emit(SOCKET_EVENTS.BG_RUN_LANE_RRWEB_BATCH, {
-				runId: jobId,
-				id: BUILT_IN_RUNNER_ID,
-				...batch
-			});
-		}
-	};
-
-	const runParams = {
-		jobId,
+	return runQueueService.enqueue({
+		kind: trigger,
+		triggerType: trigger,
+		label: trigger === TRIGGER_TYPE.MCP ? 'MCP run' : 'External run',
 		tag,
 		browser,
 		workers,
-		trigger,
-		testRunId,
 		baseUrl,
-		startedAt,
-		onLog,
-		onRRwebBatch
-	};
-	if (maxRetries === 0) {
-		runNoRetry(runParams);
-	} else {
-		runWithRetriesAndSave({ ...runParams, maxRetries });
-	}
-
-	return jobId;
+		testRunId,
+		runnerIds: [BUILT_IN_RUNNER_ID]
+	});
 }
 
-module.exports = { setSocketIO, startRun, getJob };
+const getJob = (jobId) => runQueueService.getJob(jobId);
+
+module.exports = { startRun, getJob };