plum-e2e 1.3.7 → 2.1.0

package/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   A ready-to-use E2E test automation environment built on <a href="https://playwright.dev">Playwright</a> + <a href="https://cucumber.io">Cucumber</a>.<br/>
-  Write tests in Gherkin, run them from the CLI or UI, and view reports — all in one place.
+  Write tests in Gherkin, run them from the CLI or UI, view reports, and manage your entire test case repository — all in one place.
 </p>
 
 ---
@@ -113,7 +113,23 @@ The first time you run it, Plum asks a few questions (press Enter to accept the
 | **Frontend (UI) port** | `5173`                    | Host port for the web UI                                                |
 | **Primary public URL** | `http://<your-ip>:<port>` | The address you give runner nodes (see [Runner Setup](#4-runner-setup)) |
 
-Your answers are saved to `.plum-server.json`, so the next `plum server start` reuses them without asking. When it finishes, open the UI at the frontend port it prints (default **http://localhost:5173**).
+Your answers are saved to `.plum-server.json`, so the next `plum server start` reuses them without asking.
+
+### First-user setup
+
+On the very first start, Plum detects that no user accounts exist and prompts you to create one:
+
+```
+No users found — create your first account to get started.
+✔ Your name … Jane Smith
+✔ Email address … jane@example.com
+✔ Password …
+✓ Account created for jane@example.com. You can now log in.
+```
+
+After that, open the UI at the frontend port it prints (default **http://localhost:5173**) and sign in. Additional users can be invited from **Settings → Account** or the **Settings → Users** page.
+
+> If you skip the CLI prompt, visit `http://localhost:5173/setup` in your browser to create the first account.
 
 > Docker must be running before you use this command. Plum builds and starts the backend, database, and UI automatically.
 
@@ -292,7 +308,49 @@ plum run-test --browser firefox          # run in a specific browser
 
 ---
 
-## 4. Runner Setup
+## 4. Test Repository
+
+Plum includes a built-in test case management system accessible from the **Test Repository** tab in the UI.
+
+### Test Suites and Cases
+
+Organise test cases into **suites**. Each suite and case gets an auto-assigned ID (e.g. `TS-001`, `TC-001`). The prefix is configurable in **Settings → Repository**.
+
+Each test case has:
+
+- **Title** and **Description**
+- **Priority** — Critical, High, Medium, or Low
+- **Test Steps** — an ordered table with columns: Action, Test Data, Expected Output
+- **Automated tag** — a Cucumber `@tag` name that links this case to an automated scenario (e.g. `test-login-1`)
+- **History** — a timeline of every result, from manual test runs and automated builds
+
+### Linking automated tests
+
+Set the **Automated tag** on a test case to match a Cucumber `@tag` in your feature files. After every automated run, Plum scans the results and:
+
+1. Marks matching cases as **automated**
+2. Records a pass/fail entry in the case's history
+
+```gherkin
+@test-login-1
+Scenario: User can log in with valid credentials
+```
+
+If `TC-042` has `automatedTag = test-login-1`, it will be marked automated and updated after each build — no manual linking required.
+
+### Test Runs
+
+Create a **Test Run** (e.g. "Sprint 12 regression") and drag test cases from the suite browser into the run. Then switch to **Execute** mode to step through each case and mark it pass / fail / blocked / skip.
+
+Results are recorded in the case's history and the run's progress bar updates in real time.
+
+### Migrating IDs
+
+If you change the test ID prefix (e.g. from `TC` to `CASE`), use **Settings → Repository → Run Migration** to rename all existing IDs at once. Cucumber tags in your code are intentionally left unchanged — update those separately.
+
+---
+
+## 5. Runner Setup
 
 Runners are additional machines that execute tests in parallel alongside the primary server, letting you distribute a large suite across many nodes. A node runs as a plain Node process — **no Docker required**.
 

package/backend/app.js

@@ -39,6 +39,11 @@ if (process.env.PLUM_MODE !== 'node') {
 	app.use('/settings', require('./routes/settings.routes'));
 	app.use('/backup', require('./routes/backup.routes'));
 	app.use('/runners', require('./routes/runners.routes'));
+	app.use('/auth', require('./routes/auth.routes'));
+	app.use('/users', require('./routes/users.routes'));
+	app.use('/test-suites', require('./routes/test-suites.routes'));
+	app.use('/test-cases', require('./routes/test-cases.routes'));
+	app.use('/test-runs', require('./routes/test-runs.routes'));
 }
 
 module.exports = app;

package/backend/config/scripts/create-test.mjs

@@ -0,0 +1,172 @@
+/*
+ * 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/.
+ */
+
+import * as clack from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'fs';
+import path from 'path';
+
+const testsRoot = process.env.TESTS_ROOT || path.join(process.cwd(), 'tests');
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+function toPascalCase(str) {
+	return str
+		.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase())
+		.replace(/^(.)/, (c) => c.toUpperCase());
+}
+
+function toKebabCase(str) {
+	return str
+		.replace(/([A-Z])/g, (c) => `-${c.toLowerCase()}`)
+		.replace(/[-_\s]+/g, '-')
+		.replace(/^-/, '');
+}
+
+// Strip a trailing "Page" suffix so "CheckoutPage" → base "Checkout",
+// then we append "Page" ourselves — avoiding "CheckoutPagePage".
+function stripPageSuffix(pascal) {
+	return pascal.endsWith('Page') ? pascal.slice(0, -4) : pascal;
+}
+
+/* ------------------------------------------------------------------ */
+/*  File generators                                                    */
+/* ------------------------------------------------------------------ */
+
+function generateFeature(pascal, kebab, suiteTag, testTag) {
+	return `${suiteTag}
+Feature: ${pascal}
+
+  ${testTag}
+  Scenario: Example scenario
+    Given I am on the ${pascal} page
+    When I perform an action
+    Then I should see the expected result
+`;
+}
+
+function generatePage(base) {
+	return `import { page } from '../utils/browser';
+
+export class ${base}Page {
+  static async goTo() {
+    await page().goto(process.env.BASE_URL as string);
+  }
+
+  static async performAction() {
+    // TODO: implement
+  }
+
+  static async verifyResult() {
+    // TODO: implement
+  }
+}
+`;
+}
+
+function generateSteps(pascal, base, kebab) {
+	return `import { Given, When, Then } from '@cucumber/cucumber';
+import { ${base}Page } from '../pages/${base}Page';
+
+Given('I am on the ${pascal} page', async () => {
+  await ${base}Page.goTo();
+});
+
+When('I perform an action', async () => {
+  await ${base}Page.performAction();
+});
+
+Then('I should see the expected result', async () => {
+  await ${base}Page.verifyResult();
+});
+`;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Main                                                               */
+/* ------------------------------------------------------------------ */
+
+async function main() {
+	clack.intro(pc.bgMagenta(pc.white('  🟣 Plum — Create Test  ')));
+
+	const rawName = await clack.text({
+		message: 'Feature name',
+		placeholder: 'Checkout, LoginPage, Cart…',
+		hint: 'Creates a .feature, Steps.ts and Page.ts',
+		validate: (v) => (!v.trim() ? 'Feature name is required' : undefined)
+	});
+	if (clack.isCancel(rawName)) {
+		clack.cancel('Cancelled.');
+		process.exit(0);
+	}
+
+	const pascal = toPascalCase(rawName.trim());
+	const base = stripPageSuffix(pascal); // "CheckoutPage" → "Checkout", "Cart" → "Cart"
+	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', `${base}Page.ts`);
+	const stepsPath = path.join(testsRoot, 'step_definitions', `${pascal}Steps.ts`);
+
+	const conflicts = [featurePath, pagePath, stepsPath].filter(fs.existsSync);
+	if (conflicts.length > 0) {
+		clack.log.error('The following files already exist:');
+		conflicts.forEach((f) => clack.log.warn(`  ${path.relative(process.cwd(), f)}`));
+		clack.cancel('Delete them first or choose a different name.');
+		process.exit(1);
+	}
+
+	const s = clack.spinner();
+	s.start('Generating files…');
+
+	fs.mkdirSync(path.join(testsRoot, 'features'), { recursive: true });
+	fs.mkdirSync(path.join(testsRoot, 'pages'), { recursive: true });
+	fs.mkdirSync(path.join(testsRoot, 'step_definitions'), { recursive: true });
+
+	fs.writeFileSync(featurePath, generateFeature(pascal, kebab, suiteTag, testTag), 'utf8');
+	fs.writeFileSync(pagePath, generatePage(base), 'utf8');
+	fs.writeFileSync(stepsPath, generateSteps(pascal, base, kebab), 'utf8');
+
+	s.stop(pc.green('✓ Files created'));
+
+	const rel = (p) => path.relative(process.cwd(), p);
+
+	clack.note(
+		[
+			`${pc.dim('Feature:')}  ${pc.white(rel(featurePath))}`,
+			`${pc.dim('Page:')}     ${pc.white(rel(pagePath))}`,
+			`${pc.dim('Steps:')}    ${pc.white(rel(stepsPath))}`,
+			'',
+			`${pc.dim('Suite tag:')} ${pc.cyan(suiteTag)}`,
+			`${pc.dim('Test tag:')}  ${pc.cyan(testTag)}`,
+			'',
+			`${pc.bold('Run with:')}  ${pc.cyan(`plum run-test ${testTag}`)}`
+		].join('\n'),
+		`${pascal} scaffold`
+	);
+
+	clack.outro(pc.magenta('Done! Fill in your scenarios and implement the page methods.'));
+}
+
+main().catch((err) => {
+	clack.log.error(err.message);
+	process.exit(1);
+});

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

@@ -50,7 +50,8 @@ if (process.env.PLUM_MODE === 'node') process.exit(0);
 			nodeCount,
 			browser: process.env.BROWSER || 'chromium',
 			runnerName: process.env.RUNNER_NAME || null,
-			runnerId: process.env.RUNNER_ID || null
+			runnerId: process.env.RUNNER_ID || null,
+			testRunId: process.env.TEST_RUN_ID || null
 		});
 
 		console.log(`Report saved to database (id: ${saved.id})`);

package/backend/middleware/jwtAuth.js

@@ -0,0 +1,33 @@
+/*
+ * 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 { verifyToken } = require('../services/userService');
+
+function jwtAuth(req, res, next) {
+	const auth = req.headers.authorization;
+	if (!auth || !auth.startsWith('Bearer ')) {
+		return res.status(401).json({ error: 'Unauthorized' });
+	}
+	try {
+		req.user = verifyToken(auth.slice(7));
+		next();
+	} catch {
+		return res.status(401).json({ error: 'Invalid or expired token' });
+	}
+}
+
+module.exports = { jwtAuth };

package/backend/middleware/requireAdmin.js

@@ -0,0 +1,25 @@
+/*
+ * 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/.
+ */
+
+function requireAdmin(req, res, next) {
+	if (req.user?.role !== 'admin') {
+		return res.status(403).json({ error: 'Admin access required' });
+	}
+	next();
+}
+
+module.exports = { requireAdmin };

package/backend/package.json

@@ -25,12 +25,14 @@
 		"@clack/prompts": "^1.5.1",
 		"@cucumber/cucumber": "^11.2.0",
 		"@prisma/client": "^6.19.3",
+		"bcryptjs": "^2.4.3",
 		"chai": "^4.3.6",
 		"chai-soft-assert": "^0.0.5",
 		"chokidar": "^5.0.0",
 		"cors": "^2.8.5",
 		"dotenv": "^16.4.7",
 		"express": "^4.21.2",
+		"jsonwebtoken": "^9.0.2",
 		"node-cron": "^3.0.3",
 		"picocolors": "^1.1.1",
 		"playwright": "^1.50.1",

package/backend/prisma/migrations/20260618000000_add_test_repository/migration.sql

@@ -0,0 +1,133 @@
+-- AlterTable Project: add test repository settings and sequence counters
+ALTER TABLE "Project" ADD COLUMN "testCasePrefix" TEXT NOT NULL DEFAULT 'TC';
+ALTER TABLE "Project" ADD COLUMN "testSuitePrefix" TEXT NOT NULL DEFAULT 'TS';
+ALTER TABLE "Project" ADD COLUMN "caseSeqNext" INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE "Project" ADD COLUMN "suiteSeqNext" INTEGER NOT NULL DEFAULT 0;
+
+-- AlterTable Report: add relation to TestCaseHistory (no schema change needed here, FK is on history side)
+
+-- CreateTable User
+CREATE TABLE "User" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "email" TEXT NOT NULL,
+    "password" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable TestSuite
+CREATE TABLE "TestSuite" (
+    "id" TEXT NOT NULL,
+    "displayId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT NOT NULL DEFAULT '',
+    "priority" TEXT NOT NULL DEFAULT 'Medium',
+    "createdById" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "TestSuite_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable TestCase
+CREATE TABLE "TestCase" (
+    "id" TEXT NOT NULL,
+    "displayId" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "description" TEXT NOT NULL DEFAULT '',
+    "priority" TEXT NOT NULL DEFAULT 'Medium',
+    "automatedTag" TEXT,
+    "isAutomated" BOOLEAN NOT NULL DEFAULT false,
+    "suiteId" TEXT NOT NULL,
+    "createdById" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "TestCase_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable TestStep
+CREATE TABLE "TestStep" (
+    "id" TEXT NOT NULL,
+    "caseId" TEXT NOT NULL,
+    "action" TEXT NOT NULL,
+    "testData" TEXT NOT NULL DEFAULT '',
+    "expectedOutput" TEXT NOT NULL DEFAULT '',
+    "order" INTEGER NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "TestStep_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable TestRun
+CREATE TABLE "TestRun" (
+    "id" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'draft',
+    "createdById" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "TestRun_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable TestRunEntry
+CREATE TABLE "TestRunEntry" (
+    "id" TEXT NOT NULL,
+    "runId" TEXT NOT NULL,
+    "caseId" TEXT NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'pending',
+    "notes" TEXT NOT NULL DEFAULT '',
+    "order" INTEGER NOT NULL DEFAULT 0,
+    "executedById" TEXT,
+    "executedAt" TIMESTAMP(3),
+
+    CONSTRAINT "TestRunEntry_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable TestCaseHistory
+CREATE TABLE "TestCaseHistory" (
+    "id" TEXT NOT NULL,
+    "caseId" TEXT NOT NULL,
+    "runId" TEXT,
+    "reportId" INTEGER,
+    "result" TEXT NOT NULL,
+    "source" TEXT NOT NULL DEFAULT 'manual',
+    "notes" TEXT NOT NULL DEFAULT '',
+    "executedById" TEXT,
+    "executedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "TestCaseHistory_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "User_email_key" ON "User"("email");
+CREATE UNIQUE INDEX "TestSuite_displayId_key" ON "TestSuite"("displayId");
+CREATE UNIQUE INDEX "TestCase_displayId_key" ON "TestCase"("displayId");
+
+-- AddForeignKey
+ALTER TABLE "TestSuite" ADD CONSTRAINT "TestSuite_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TestCase" ADD CONSTRAINT "TestCase_suiteId_fkey" FOREIGN KEY ("suiteId") REFERENCES "TestSuite"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "TestCase" ADD CONSTRAINT "TestCase_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TestStep" ADD CONSTRAINT "TestStep_caseId_fkey" FOREIGN KEY ("caseId") REFERENCES "TestCase"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TestRun" ADD CONSTRAINT "TestRun_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TestRunEntry" ADD CONSTRAINT "TestRunEntry_runId_fkey" FOREIGN KEY ("runId") REFERENCES "TestRun"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "TestRunEntry" ADD CONSTRAINT "TestRunEntry_caseId_fkey" FOREIGN KEY ("caseId") REFERENCES "TestCase"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "TestRunEntry" ADD CONSTRAINT "TestRunEntry_executedById_fkey" FOREIGN KEY ("executedById") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TestCaseHistory" ADD CONSTRAINT "TestCaseHistory_caseId_fkey" FOREIGN KEY ("caseId") REFERENCES "TestCase"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "TestCaseHistory" ADD CONSTRAINT "TestCaseHistory_runId_fkey" FOREIGN KEY ("runId") REFERENCES "TestRun"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+ALTER TABLE "TestCaseHistory" ADD CONSTRAINT "TestCaseHistory_reportId_fkey" FOREIGN KEY ("reportId") REFERENCES "Report"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+ALTER TABLE "TestCaseHistory" ADD CONSTRAINT "TestCaseHistory_executedById_fkey" FOREIGN KEY ("executedById") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;

package/backend/prisma/migrations/20260618000001_add_user_roles/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable User: add role column, promote first user to admin
+ALTER TABLE "User" ADD COLUMN "role" TEXT NOT NULL DEFAULT 'user';
+UPDATE "User" SET "role" = 'admin' WHERE "id" = (SELECT "id" FROM "User" ORDER BY "createdAt" ASC LIMIT 1);

package/backend/prisma/migrations/20260618000002_drop_automated_tag/migration.sql

@@ -0,0 +1,2 @@
+-- TestCase.automatedTag removed: displayId is now used directly as the Cucumber tag identifier
+ALTER TABLE "TestCase" DROP COLUMN IF EXISTS "automatedTag";

package/backend/prisma/migrations/20260618000003_entry_assignee/migration.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "TestRunEntry" ADD COLUMN "assignedToId" TEXT;
+ALTER TABLE "TestRunEntry" ADD CONSTRAINT "TestRunEntry_assignedToId_fkey" FOREIGN KEY ("assignedToId") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;

package/backend/prisma/schema.prisma

@@ -51,23 +51,131 @@ model CronJob {
 }
 
 model Report {
-  id          Int      @id @default(autoincrement())
+  id          Int               @id @default(autoincrement())
   status      String
   tags        String
-  triggerType String   @default("manual-trigger")
-  runners     Int      @default(1)
-  browser     String   @default("chromium")
+  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)
+  runner      Runner?           @relation(fields: [runnerId], references: [id], onDelete: SetNull)
   cronJobId   Int?
-  cronJob     CronJob? @relation(fields: [cronJobId], references: [id], onDelete: SetNull)
+  cronJob     CronJob?          @relation(fields: [cronJobId], references: [id], onDelete: SetNull)
   content     Json
-  createdAt   DateTime @default(now())
+  createdAt   DateTime          @default(now())
+  testHistory TestCaseHistory[]
 }
 
 model Project {
-  id      Int    @id @default(autoincrement())
-  name    String @default("")
-  logoUrl String @default("")
+  id              Int    @id @default(autoincrement())
+  name            String @default("")
+  logoUrl         String @default("")
+  testCasePrefix  String @default("TC")
+  testSuitePrefix String @default("TS")
+  caseSeqNext     Int    @default(0)
+  suiteSeqNext    Int    @default(0)
+}
+
+model User {
+  id        String   @id @default(cuid())
+  name      String
+  email     String   @unique
+  password  String
+  role      String   @default("user")
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  suites          TestSuite[]
+  cases           TestCase[]
+  runs            TestRun[]
+  executedEntries TestRunEntry[]   @relation("entryExecutor")
+  assignedEntries TestRunEntry[]   @relation("entryAssignee")
+  caseHistories   TestCaseHistory[]
+}
+
+model TestSuite {
+  id          String     @id @default(cuid())
+  displayId   String     @unique
+  name        String
+  description String     @default("")
+  priority    String     @default("Medium")
+  createdById String
+  createdBy   User       @relation(fields: [createdById], references: [id])
+  createdAt   DateTime   @default(now())
+  updatedAt   DateTime   @updatedAt
+  cases       TestCase[]
+}
+
+model TestCase {
+  id           String            @id @default(cuid())
+  displayId    String            @unique
+  title        String
+  description  String            @default("")
+  priority     String            @default("Medium")
+  isAutomated  Boolean           @default(false)
+  suiteId      String
+  suite        TestSuite         @relation(fields: [suiteId], references: [id], onDelete: Cascade)
+  createdById  String
+  createdBy    User              @relation(fields: [createdById], references: [id])
+  createdAt    DateTime          @default(now())
+  updatedAt    DateTime          @updatedAt
+  steps        TestStep[]
+  runEntries   TestRunEntry[]
+  history      TestCaseHistory[]
+}
+
+model TestStep {
+  id             String   @id @default(cuid())
+  caseId         String
+  case           TestCase @relation(fields: [caseId], references: [id], onDelete: Cascade)
+  action         String
+  testData       String   @default("")
+  expectedOutput String   @default("")
+  order          Int
+  createdAt      DateTime @default(now())
+}
+
+model TestRun {
+  id          String         @id @default(cuid())
+  title       String
+  status      String         @default("backlog")
+  createdById String
+  createdBy   User           @relation(fields: [createdById], references: [id])
+  createdAt   DateTime       @default(now())
+  updatedAt   DateTime       @updatedAt
+  entries     TestRunEntry[]
+  history     TestCaseHistory[]
+}
+
+model TestRunEntry {
+  id           String    @id @default(cuid())
+  runId        String
+  run          TestRun   @relation(fields: [runId], references: [id], onDelete: Cascade)
+  caseId       String
+  case         TestCase  @relation(fields: [caseId], references: [id], onDelete: Cascade)
+  status       String    @default("pending")
+  notes        String    @default("")
+  order        Int       @default(0)
+  executedById String?
+  executedBy   User?     @relation("entryExecutor", fields: [executedById], references: [id])
+  executedAt   DateTime?
+  assignedToId String?
+  assignedTo   User?     @relation("entryAssignee", fields: [assignedToId], references: [id])
+}
+
+model TestCaseHistory {
+  id           String    @id @default(cuid())
+  caseId       String
+  case         TestCase  @relation(fields: [caseId], references: [id], onDelete: Cascade)
+  runId        String?
+  run          TestRun?  @relation(fields: [runId], references: [id], onDelete: SetNull)
+  reportId     Int?
+  report       Report?   @relation(fields: [reportId], references: [id], onDelete: SetNull)
+  result       String
+  source       String    @default("manual")
+  notes        String    @default("")
+  executedById String?
+  executedBy   User?     @relation(fields: [executedById], references: [id])
+  executedAt   DateTime  @default(now())
 }