plum-e2e 1.0.10 → 1.1.0

package/backend/package.json

@@ -3,6 +3,8 @@
 	"version": "1.0.0",
 	"main": "index.js",
 	"scripts": {
+		"init": "node services/envService.js && node config/scripts/create-settings.js",
+		"create-step": "node config/scripts/create-step.mjs",
 		"create-env": "node services/envService.js",
 		"test": "node config/scripts/run-tests.js"
 	},
@@ -13,11 +15,11 @@
 		"@playwright/test": "^1.50.1",
 		"@types/node": "^22.17.0",
 		"cross-env": "^7.0.3",
-		"cucumber-html-reporter": "^7.2.0",
 		"ts-node": "^10.9.2",
 		"typescript": "^5.9.2"
 	},
 	"dependencies": {
+		"@clack/prompts": "^1.5.1",
 		"@cucumber/cucumber": "^11.2.0",
 		"chai": "^4.3.6",
 		"chai-soft-assert": "^0.0.5",
@@ -25,6 +27,7 @@
 		"dotenv": "^16.4.7",
 		"express": "^4.21.2",
 		"node-cron": "^3.0.3",
+		"picocolors": "^1.1.1",
 		"playwright": "^1.50.1",
 		"socket.io": "^4.8.1"
 	}

package/backend/routes/reports.routes.js

@@ -19,24 +19,20 @@ const express = require('express');
 const router = express.Router();
 const reportService = require('../services/reportService');
 
-/* -----------------------------------------------------
- *                    Get Reports
- *  Description:
- * 		Get all reports from reports/
- * ------------------------------------------------------ */
 router.get('/', (req, res) => {
 	const reports = reportService.getAllReports();
 	res.json({ reports });
 });
 
-/* -----------------------------------------------------
- *                  Get Latest Report
- *  Description:
- * 		Get latest report
- * ------------------------------------------------------ */
 router.get('/latest', (req, res) => {
 	const latestReport = reportService.getLatestReport();
 	res.json({ latestReport });
 });
 
+router.get('/:fileName/detail', (req, res) => {
+	const detail = reportService.getReportDetail(req.params.fileName);
+	if (!detail) return res.status(404).json({ error: 'Report not found' });
+	res.json(detail);
+});
+
 module.exports = router;

package/backend/services/envService.js

@@ -17,27 +17,21 @@
 
 const fs = require('fs');
 const path = require('path');
+const pc = require('picocolors');
 
-/* -----------------------------------------------------
- *                   .env Generator
- *  Description:
- * 		If .env file doesn't exist, this will create
- * 		a .env file in root with sauce demo's base URL
- * ------------------------------------------------------ */
 const envPath = path.join(__dirname, '../.env');
 
 if (!fs.existsSync(envPath)) {
 	const envContent = 'BASE_URL=https://www.saucedemo.com/v1/\nIS_HEADLESS=false';
 	fs.writeFileSync(envPath, envContent);
-	console.log('.env file created in the root directory');
+	console.log(pc.green('✓') + ' .env created with default values.');
 } else {
 	let envContent = fs.readFileSync(envPath, 'utf8');
-
 	if (!envContent.includes('IS_HEADLESS=')) {
 		envContent += '\nIS_HEADLESS=false';
 		fs.writeFileSync(envPath, envContent);
-		console.log('IS_HEADLESS=false added to .env');
+		console.log(pc.cyan('↳') + ' IS_HEADLESS=false added to .env.');
 	} else {
-		console.log('.env file already contains IS_HEADLESS setting');
+		console.log(pc.yellow('⚠') + ' .env already exists. Skipping.');
 	}
 }

package/backend/services/reportService.js

@@ -22,29 +22,79 @@ const REPORTS_DIR = path.join(__dirname, '../reports');
 
 const getAllReports = () => {
 	const files = fs.readdirSync(REPORTS_DIR);
-
-	// Get all files ending with '.html'
-	const htmlFiles = files.filter((file) => file.endsWith('.html'));
-
-	// Sort files by modification time (latest first)
-	const sortedFiles = htmlFiles.sort((a, b) => {
-		const aStats = fs.statSync(path.join(REPORTS_DIR, a));
-		const bStats = fs.statSync(path.join(REPORTS_DIR, b));
-		return bStats.mtime - aStats.mtime; // Sort in descending order of modification time
+	const jsonFiles = files.filter(
+		(f) => f.endsWith('.json') && (f.startsWith('PASS_') || f.startsWith('FAIL_'))
+	);
+	return jsonFiles.sort((a, b) => {
+		const at = fs.statSync(path.join(REPORTS_DIR, a)).mtime;
+		const bt = fs.statSync(path.join(REPORTS_DIR, b)).mtime;
+		return bt - at;
 	});
-
-	return sortedFiles;
 };
 
 const getLatestReport = () => {
-	const reportFiles = getAllReports()
-		.map((file) => ({
-			file,
-			time: fs.statSync(path.join(REPORTS_DIR, file)).mtime.getTime()
-		}))
-		.sort((a, b) => b.time - a.time);
-
-	return reportFiles.length ? reportFiles[0].file : null;
+	const files = getAllReports();
+	return files.length ? files[0] : null;
+};
+
+const getReportDetail = (fileName) => {
+	const filePath = path.join(REPORTS_DIR, fileName);
+	if (!filePath.startsWith(REPORTS_DIR)) return null; // path traversal guard
+	if (!fs.existsSync(filePath)) return null;
+
+	let raw;
+	try {
+		raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+	} catch {
+		return null;
+	}
+
+	const features = raw.map((feature) => {
+		const scenarios = (feature.elements || []).map((scenario) => {
+			const visibleSteps = (scenario.steps || []).filter((s) => !s.hidden);
+			const hookScreenshots = (scenario.steps || [])
+				.filter((s) => s.hidden)
+				.flatMap((step) => step.embeddings?.filter((e) => e.mime_type === 'image/png') ?? []);
+			const failedStepIndex = visibleSteps.findLastIndex((s) => s.result?.status === 'failed');
+
+			const steps = visibleSteps.map((step, index) => ({
+				keyword: step.keyword.trim(),
+				name: step.name ?? '',
+				status: step.result?.status ?? 'pending',
+				duration: Math.round((step.result?.duration ?? 0) / 1_000_000), // ns → ms
+				error: step.result?.error_message ?? null,
+				screenshot:
+					step.embeddings?.find((e) => e.mime_type === 'image/png')?.data ??
+					(index === failedStepIndex ? hookScreenshots[0]?.data : null) ??
+					null
+			}));
+
+			const worstStatus = steps.reduce((acc, s) => {
+				const rank = { failed: 3, pending: 2, skipped: 1, passed: 0 };
+				return (rank[s.status] ?? 0) > (rank[acc] ?? 0) ? s.status : acc;
+			}, 'passed');
+
+			return {
+				name: scenario.name,
+				keyword: scenario.keyword,
+				tags: (scenario.tags ?? []).map((t) => t.name),
+				status: worstStatus,
+				duration: steps.reduce((s, st) => s + st.duration, 0),
+				steps
+			};
+		});
+
+		const featureStatus = scenarios.some((s) => s.status === 'failed') ? 'failed' : 'passed';
+
+		return {
+			name: feature.name,
+			uri: feature.uri,
+			status: featureStatus,
+			scenarios
+		};
+	});
+
+	return { features };
 };
 
-module.exports = { getAllReports, getLatestReport };
+module.exports = { getAllReports, getLatestReport, getReportDetail };

package/backend/services/testService.js

@@ -22,45 +22,120 @@ const FEATURES_DIR = path.join(__dirname, '../tests/features');
 
 const getTestSuites = () => {
 	const suites = [];
-
-	const files = fs.readdirSync(FEATURES_DIR).filter((file) => file.endsWith('.feature'));
+	const files = fs.readdirSync(FEATURES_DIR).filter((f) => f.endsWith('.feature'));
 
 	files.forEach((file) => {
 		const content = fs.readFileSync(path.join(FEATURES_DIR, file), 'utf8');
+		const lines = content.split('\n');
 
 		let suiteName = '';
 		let suiteTags = [];
+		let backgroundSteps = [];
 		const tests = [];
 
-		// Suites Tag Extractor
-		const featureMatch = content.match(/Feature:\s*(.+)/);
-		if (featureMatch) {
-			suiteName = featureMatch[1].trim();
-		}
+		let inBackground = false;
+		let inExamples = false;
+		let pendingTags = [];
+		let currentTest = null;
 
-		const suiteTagsMatch = content.match(/^(@[^\n]+)/m);
-		if (suiteTagsMatch) {
-			suiteTags = suiteTagsMatch[0].split(/\s+/).filter((tag) => tag.trim() !== ''); // Remove empty elements
-		}
+		const finalizeTest = () => {
+			if (currentTest) {
+				tests.push(currentTest);
+				currentTest = null;
+			}
+		};
 
-		// Test Cases Tag Extractor
-		const scenarioMatches = [...content.matchAll(/(@[^\n]+)\s*Scenario:\s*(.+)/g)];
-		scenarioMatches.forEach((match) => {
-			const tags = match[1].split(/\s+/).filter((tag) => tag.trim() !== ''); // Remove empty elements
-			const scenarioText = match[2].trim();
+		for (const raw of lines) {
+			const trimmed = raw.trim();
+			if (!trimmed || trimmed.startsWith('#')) continue;
 
-			if (tags.length === 0) return; // Skip if there are no valid tags
+			// Tag line
+			if (trimmed.startsWith('@')) {
+				finalizeTest();
+				inBackground = false;
+				inExamples = false;
+				const tags = trimmed.split(/\s+/).filter(Boolean);
+				if (!suiteName) {
+					suiteTags = [...suiteTags, ...tags];
+				} else {
+					pendingTags = [...pendingTags, ...tags];
+				}
+				continue;
+			}
 
-			const testId = tags.shift(); // Extract the first tag as testId
+			// Feature
+			if (trimmed.startsWith('Feature:')) {
+				suiteName = trimmed.replace('Feature:', '').trim();
+				continue;
+			}
 
-			tests.push({
-				id: tags.length > 0 ? [testId, ...tags] : testId, // Ensure testId is correctly structured
-				testCase: scenarioText
-			});
-		});
+			// Background
+			if (trimmed.startsWith('Background:')) {
+				inBackground = true;
+				inExamples = false;
+				continue;
+			}
+
+			// Scenario or Scenario Outline
+			const scenarioMatch = trimmed.match(/^Scenario(?:\s+Outline)?:\s*(.+)/i);
+			if (scenarioMatch) {
+				finalizeTest();
+				inBackground = false;
+				inExamples = false;
+
+				const isOutline = /^Scenario\s+Outline:/i.test(trimmed);
+				const tags = pendingTags.splice(0);
+				const [testId, ...extraTags] = tags;
+
+				currentTest = {
+					id: extraTags.length > 0 ? [testId, ...extraTags] : testId,
+					testCase: scenarioMatch[1].trim(),
+					type: isOutline ? 'outline' : 'scenario',
+					steps: [...backgroundSteps],
+					...(isOutline ? { examples: null } : {})
+				};
+				continue;
+			}
+
+			// Examples header (Scenario Outline)
+			if (trimmed.startsWith('Examples:')) {
+				inExamples = true;
+				if (currentTest) currentTest.examples = { headers: [], rows: [] };
+				continue;
+			}
+
+			// Step lines
+			if (/^(Given|When|Then|And|But)\s/i.test(trimmed)) {
+				if (inBackground) {
+					backgroundSteps.push(trimmed);
+				} else if (currentTest && !inExamples) {
+					currentTest.steps.push(trimmed);
+				}
+				continue;
+			}
+
+			// Examples table rows
+			if (inExamples && trimmed.startsWith('|') && currentTest?.examples) {
+				const cells = trimmed
+					.split('|')
+					.filter(Boolean)
+					.map((c) => c.trim());
+				if (currentTest.examples.headers.length === 0) {
+					currentTest.examples.headers = cells;
+				} else {
+					currentTest.examples.rows.push(cells);
+				}
+			}
+		}
+
+		finalizeTest();
 
 		if (suiteName && tests.length) {
-			suites.push({ suiteName, suiteId: suiteTags.length > 1 ? suiteTags : suiteTags[0], tests });
+			suites.push({
+				suiteName,
+				suiteId: suiteTags.length > 1 ? suiteTags : suiteTags[0],
+				tests
+			});
 		}
 	});
 

package/backend/tsconfig.json

@@ -1,8 +1,8 @@
 {
 	"compilerOptions": {
 		"target": "ES2020",
-		"module": "CommonJS",
-		"moduleResolution": "node",
+		"module": "Node16",
+		"moduleResolution": "node16",
 		"esModuleInterop": true,
 		"strict": true,
 		"skipLibCheck": true,

package/backend/websockets/socketHandler.js

@@ -20,12 +20,18 @@ const { spawn } = require('child_process');
 const socketHandler = (io) => {
 	io.on('connection', (socket) => {
 		console.log('WebSocket connection established');
-		socket.on('run-test', (testID) => {
+		socket.on('run-test', (testID, workers) => {
 			const tag = testID ? `${testID}` : '';
+			const runnerCount = Number(workers) > 1 ? Number(workers) : 1;
+			const env = {
+				...process.env,
+				TAG: tag,
+				TRIGGER: 'manual-trigger',
+				REPORT_RUNNERS: String(runnerCount)
+			};
+			if (workers && workers > 1) env.PARALLEL = String(workers);
 
-			const testProcess = spawn('npm', ['run', 'test'], {
-				env: { ...process.env, TAG: tag, TRIGGER: 'manual-trigger' }
-			});
+			const testProcess = spawn('npm', ['run', 'test'], { env });
 
 			testProcess.stdout.on('data', (data) => {
 				socket.emit('log', data.toString());
@@ -36,8 +42,8 @@ const socketHandler = (io) => {
 			});
 
 			testProcess.on('close', (code) => {
-				socket.emit('log', `Test finished with code ${code}`);
-				socket.emit('done');
+				socket.emit('log', `\nTest finished with code ${code}`);
+				socket.emit('done', code);
 			});
 		});
 	});

package/bin/plum.js

@@ -91,6 +91,34 @@ switch (command) {
 		// Create .env file with default values
 		createEnvFile();
 
+		// Create .vscode/settings.json for Cucumber extension step linkage
+		const vscodeSettingsPath = path.join(process.cwd(), '.vscode', 'settings.json');
+		if (!fs.existsSync(vscodeSettingsPath)) {
+			fs.mkdirSync(path.dirname(vscodeSettingsPath), { recursive: true });
+			const vscodeSettings = JSON.stringify(
+				{
+					'cucumber.glue': ['tests/step_definitions/**/*.ts'],
+					'cucumber.features': ['tests/features/**/*.feature']
+				},
+				null,
+				2
+			);
+			fs.writeFileSync(vscodeSettingsPath, vscodeSettings, 'utf8');
+			console.log('✅ .vscode/settings.json created for Cucumber extension.\n');
+		} else {
+			console.log('⚠️  .vscode/settings.json already exists. Skipping.\n');
+		}
+
+		// Install Cucumber VS Code extension
+		try {
+			execSync('code --install-extension cucumberopen.cucumber-official', { stdio: 'inherit' });
+			console.log('✅ Cucumber VS Code extension installed.\n');
+		} catch {
+			console.log(
+				'⚠️  Could not install VS Code extension automatically. Install manually: cucumberopen.cucumber-official\n'
+			);
+		}
+
 		// Initialize project
 		console.log('--------------------------------------\n');
 		console.log('🚀 Initializing Plum...');
@@ -152,7 +180,10 @@ switch (command) {
 		// Copy .env file from root to backend
 		copyEnvFile();
 
-		const tagArg = process.argv[3]; // This is your tag, like @test-1
+		const devArgs = process.argv.slice(3);
+		const parallelIdx = devArgs.indexOf('--parallel');
+		const parallelArg = parallelIdx !== -1 ? devArgs[parallelIdx + 1] : null;
+		const tagArg = devArgs.find((a) => a.startsWith('@')) ?? null;
 		const userTestsPath = path.resolve(process.cwd(), 'tests');
 		const backendTestsPath = path.join(plumRoot, 'backend', 'tests');
 
@@ -184,6 +215,7 @@ switch (command) {
 		console.log('--------------------------------------\n');
 		console.log('Running `npm run test` with:');
 		console.log('TAG =', tagArg ?? '');
+		console.log('PARALLEL =', parallelArg ?? 'off');
 		console.log('TRIGGER =', 'command-line-trigger');
 
 		execSync('npm run test', {
@@ -192,15 +224,29 @@ switch (command) {
 			env: {
 				...process.env,
 				TAG: tagArg ?? '',
-				TRIGGER: 'command-line-trigger'
+				TRIGGER: 'command-line-trigger',
+				...(parallelArg ? { PARALLEL: parallelArg } : {})
 			}
 		});
 		console.log('--------------------------------------\n');
 		break;
 	}
 
+	case 'create-step': {
+		const createStepScript = path.join(plumRoot, 'backend', 'config', 'scripts', 'create-step.mjs');
+		execSync(`node ${createStepScript}`, {
+			cwd: process.cwd(),
+			stdio: 'inherit',
+			env: {
+				...process.env,
+				TESTS_ROOT: userTestsPath
+			}
+		});
+		break;
+	}
+
 	default:
 		console.log('--------------------------------------\n');
-		console.log('Usage: plum <init|start|dev>');
+		console.log('Usage: plum <init|start|dev|create-step>');
 		console.log('--------------------------------------\n');
 }