plum-e2e 1.3.7 → 2.1.0

package/backend/routes/auth.routes.js

@@ -0,0 +1,96 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const userService = require('../services/userService');
+const { jwtAuth } = require('../middleware/jwtAuth');
+
+router.get('/needs-setup', async (req, res, next) => {
+	try {
+		const setup = await userService.needsSetup();
+		res.json({ needsSetup: setup });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/setup', async (req, res, next) => {
+	try {
+		const setup = await userService.needsSetup();
+		if (!setup) return res.status(403).json({ error: 'Setup already complete' });
+		const { name, email, password } = req.body;
+		if (!name || !email || !password)
+			return res.status(400).json({ error: 'name, email and password are required' });
+		const user = await userService.createUser({ name, email, password, role: 'admin' });
+		res.status(201).json({ user });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/login', async (req, res, next) => {
+	try {
+		const { email, password } = req.body;
+		if (!email || !password)
+			return res.status(400).json({ error: 'email and password are required' });
+		const result = await userService.login({ email, password });
+		if (!result) return res.status(401).json({ error: 'Invalid credentials' });
+		res.json(result);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/me', jwtAuth, async (req, res, next) => {
+	try {
+		const user = await userService.getById(req.user.userId);
+		if (!user) return res.status(404).json({ error: 'User not found' });
+		res.json({ user });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/change-password', jwtAuth, async (req, res, next) => {
+	try {
+		const { currentPassword, newPassword } = req.body;
+		if (!currentPassword || !newPassword)
+			return res.status(400).json({ error: 'currentPassword and newPassword are required' });
+		const result = await userService.updatePassword(req.user.userId, {
+			currentPassword,
+			newPassword
+		});
+		if (!result.ok) return res.status(400).json({ error: result.error });
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/update-profile', jwtAuth, async (req, res, next) => {
+	try {
+		const { name, email } = req.body;
+		const result = await userService.updateProfile(req.user.userId, { name, email });
+		if (!result.ok) return res.status(400).json({ error: result.error });
+		res.json({ user: result.user });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/routes/settings.routes.js

@@ -18,25 +18,61 @@
 const express = require('express');
 const router = express.Router();
 const settingsService = require('../services/settingsService');
+const testSuiteService = require('../services/testSuiteService');
+const testCaseService = require('../services/testCaseService');
+const { jwtAuth } = require('../middleware/jwtAuth');
 
-router.get('/project', async (req, res) => {
+router.get('/project', async (req, res, next) => {
 	try {
 		const project = await settingsService.getProject();
 		res.json(project);
-	} catch (error) {
-		console.error('Error fetching project settings:', error);
-		res.status(500).json({ error: 'Failed to fetch project settings' });
+	} catch (e) {
+		next(e);
 	}
 });
 
-router.post('/project', async (req, res) => {
+router.post('/project', async (req, res, next) => {
 	try {
 		const { name, logoUrl } = req.body;
 		const project = await settingsService.updateProject({ name, logoUrl });
 		res.json(project);
-	} catch (error) {
-		console.error('Error updating project settings:', error);
-		res.status(500).json({ error: 'Failed to update project settings' });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/test-prefixes', jwtAuth, async (req, res, next) => {
+	try {
+		const prefixes = await settingsService.getTestPrefixes();
+		res.json(prefixes);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/test-prefixes', jwtAuth, async (req, res, next) => {
+	try {
+		const { testCasePrefix, testSuitePrefix } = req.body;
+		const project = await settingsService.updateTestPrefixes({ testCasePrefix, testSuitePrefix });
+		res.json(project);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/test-prefixes/migrate', jwtAuth, async (req, res, next) => {
+	try {
+		const { testCasePrefix, testSuitePrefix } = req.body;
+		const results = {};
+		if (testCasePrefix) {
+			results.cases = await testCaseService.migratePrefix(testCasePrefix);
+		}
+		if (testSuitePrefix) {
+			results.suites = await testSuiteService.migratePrefix(testSuitePrefix);
+		}
+		res.json({ ok: true, ...results });
+	} catch (e) {
+		next(e);
 	}
 });
 

package/backend/routes/test-cases.routes.js

@@ -0,0 +1,80 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const testCaseService = require('../services/testCaseService');
+
+router.get('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const tc = await testCaseService.getById(req.params.id);
+		if (!tc) return res.status(404).json({ error: 'Test case not found' });
+		res.json({ testCase: tc });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, async (req, res, next) => {
+	try {
+		const { suiteId, title, description, priority } = req.body;
+		if (!suiteId || !title)
+			return res.status(400).json({ error: 'suiteId and title are required' });
+		const testCase = await testCaseService.create({
+			suiteId,
+			title,
+			description,
+			priority,
+			createdById: req.user.userId
+		});
+		res.status(201).json({ testCase });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const { title, description, priority } = req.body;
+		const testCase = await testCaseService.update(req.params.id, { title, description, priority });
+		res.json({ testCase });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/:id/steps', jwtAuth, async (req, res, next) => {
+	try {
+		const { steps } = req.body;
+		const saved = await testCaseService.upsertSteps(req.params.id, steps);
+		res.json({ steps: saved });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		await testCaseService.remove(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/routes/test-runs.routes.js

@@ -0,0 +1,122 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const testRunService = require('../services/testRunService');
+
+router.get('/', jwtAuth, async (req, res, next) => {
+	try {
+		const page = Math.max(1, parseInt(req.query.page) || 1);
+		const limit = Math.min(200, Math.max(1, parseInt(req.query.limit) || 20));
+		const { q, sortBy, sortOrder } = req.query;
+		const result = await testRunService.getAll({ page, limit, q, sortBy, sortOrder });
+		res.json(result);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const run = await testRunService.getById(req.params.id);
+		if (!run) return res.status(404).json({ error: 'Test run not found' });
+		res.json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, async (req, res, next) => {
+	try {
+		const { title, caseIds } = req.body;
+		if (!title) return res.status(400).json({ error: 'title is required' });
+		const run = await testRunService.create({ title, caseIds, createdById: req.user.userId });
+		res.status(201).json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const { title, status, caseIds } = req.body;
+		const run = await testRunService.update(req.params.id, { title, status, caseIds });
+		res.json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/:id/duplicate', jwtAuth, async (req, res, next) => {
+	try {
+		const run = await testRunService.duplicate(req.params.id, { createdById: req.user.userId });
+		if (!run) return res.status(404).json({ error: 'Test run not found' });
+		res.status(201).json({ run });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		await testRunService.remove(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/entries/:entryId/assign', jwtAuth, async (req, res, next) => {
+	try {
+		const { userId } = req.body;
+		const entry = await testRunService.assignEntry(req.params.entryId, { userId: userId ?? null });
+		res.json({ entry });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/entries/:entryId/result', jwtAuth, async (req, res, next) => {
+	try {
+		const { status, notes } = req.body;
+		if (!status) return res.status(400).json({ error: 'status is required' });
+		const entry = await testRunService.updateEntry(req.params.entryId, {
+			status,
+			notes,
+			executedById: req.user.userId
+		});
+		res.json({ entry });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/:id/reorder', jwtAuth, async (req, res, next) => {
+	try {
+		const { entryIds } = req.body;
+		if (!Array.isArray(entryIds))
+			return res.status(400).json({ error: 'entryIds must be an array' });
+		await testRunService.reorderEntries(req.params.id, entryIds);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/routes/test-suites.routes.js

@@ -0,0 +1,92 @@
+/*
+ * 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 express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const testSuiteService = require('../services/testSuiteService');
+
+router.get('/', jwtAuth, async (req, res, next) => {
+	try {
+		if (req.query.withCases === 'true') {
+			const suites = await testSuiteService.getAllWithCases();
+			return res.json({ suites });
+		}
+		if (req.query.q) {
+			const results = await testSuiteService.search(req.query.q);
+			return res.json(results);
+		}
+		const page = Math.max(1, parseInt(req.query.page) || 1);
+		const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 20));
+		const { sortBy, sortOrder } = req.query;
+		const result = await testSuiteService.getAll({ page, limit, sortBy, sortOrder });
+		res.json(result);
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const suite = await testSuiteService.getById(req.params.id);
+		if (!suite) return res.status(404).json({ error: 'Suite not found' });
+		res.json({ suite });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, async (req, res, next) => {
+	try {
+		const { name, description, priority } = req.body;
+		if (!name) return res.status(400).json({ error: 'name is required' });
+		const suite = await testSuiteService.create({
+			name,
+			description,
+			priority,
+			createdById: req.user.userId
+		});
+		res.status(201).json({ suite });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.put('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		const { name, description, priority } = req.body;
+		const suite = await testSuiteService.update(req.params.id, {
+			name,
+			description,
+			priority
+		});
+		res.json({ suite });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, async (req, res, next) => {
+	try {
+		await testSuiteService.remove(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/routes/users.routes.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/.
+ */
+
+const express = require('express');
+const router = express.Router();
+const { jwtAuth } = require('../middleware/jwtAuth');
+const { requireAdmin } = require('../middleware/requireAdmin');
+const userService = require('../services/userService');
+
+router.get('/members', jwtAuth, async (req, res, next) => {
+	try {
+		const users = await userService.getMembers();
+		res.json({ users });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.get('/', jwtAuth, requireAdmin, async (req, res, next) => {
+	try {
+		const users = await userService.getAll();
+		res.json({ users });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.post('/', jwtAuth, requireAdmin, async (req, res, next) => {
+	try {
+		const { name, email, password, role = 'user' } = req.body;
+		if (!name || !email || !password)
+			return res.status(400).json({ error: 'name, email and password are required' });
+		if (!['admin', 'user'].includes(role))
+			return res.status(400).json({ error: 'role must be admin or user' });
+		const user = await userService.createUser({ name, email, password, role });
+		res.status(201).json({ user });
+	} catch (e) {
+		next(e);
+	}
+});
+
+router.delete('/:id', jwtAuth, requireAdmin, async (req, res, next) => {
+	try {
+		if (req.params.id === req.user.userId)
+			return res.status(400).json({ error: 'Cannot delete your own account' });
+		await userService.deleteUser(req.params.id);
+		res.json({ ok: true });
+	} catch (e) {
+		next(e);
+	}
+});
+
+module.exports = router;

package/backend/scripts/create-test.js

@@ -64,12 +64,13 @@ async function main() {
 	}
 
 	const pascal = toPascalCase(rawName);
+	const base = pascal.endsWith('Page') ? pascal.slice(0, -4) : pascal;
 	const kebab = toKebabCase(pascal);
 	const suiteTag = `@suite-${kebab}`;
 	const testTag = `@test-${kebab}-1`;
 
 	const featurePath = path.join(testsRoot, 'features', `${pascal}.feature`);
-	const pagePath = path.join(testsRoot, 'pages', `${pascal}Page.ts`);
+	const pagePath = path.join(testsRoot, 'pages', `${base}Page.ts`);
 	const stepsPath = path.join(testsRoot, 'step_definitions', `${pascal}Steps.ts`);
 
 	const conflicts = [featurePath, pagePath, stepsPath].filter(fs.existsSync);
@@ -95,7 +96,7 @@ Feature: ${pascal}
 
 	const page = `import { page } from '../utils/browser';
 
-export class ${pascal}Page {
+export class ${base}Page {
   static async goTo() {
     await page().goto(process.env.BASE_URL as string);
   }
@@ -111,18 +112,18 @@ export class ${pascal}Page {
 `;
 
 	const steps = `import { Given, When, Then } from '@cucumber/cucumber';
-import { ${pascal}Page } from '../pages/${pascal}Page';
+import { ${base}Page } from '../pages/${base}Page';
 
 Given('I am on the ${pascal} page', async () => {
-  await ${pascal}Page.goTo();
+  await ${base}Page.goTo();
 });
 
 When('I perform an action', async () => {
-  await ${pascal}Page.performAction();
+  await ${base}Page.performAction();
 });
 
 Then('I should see the expected result', async () => {
-  await ${pascal}Page.verifyResult();
+  await ${base}Page.verifyResult();
 });
 `;