create-appraisejs 0.3.1-alpha.0 → 0.3.1-alpha.1

package/templates/starter/automation/steps/validations/text_assertion.step.ts

@@ -1,108 +1,68 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name text assertion
- * @description Template steps for asserting text inside elements
- * @type VALIDATION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name assert element contains text
- * @description Template step for validating whether an element contains a certain text or not
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should {boolean} contain the text {string}',
-  async function (
-    this: CustomWorld,
-    elementName: SelectorName,
-    shouldContain: boolean,
-    elementText: string
-  ) {
-    try {
-      const selector = await resolveLocator(this.page, elementName);
-      if (!selector) throw new Error(`Selector ${elementName} not found`);
-      const elementTextContent = await this.page
-        .locator(selector)
-        .textContent();
-
-      if (!elementTextContent)
-        throw new Error(
-          `Element ${elementName} does not have any text content`
-        );
-
-      if (shouldContain) {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} to contain "${elementText}"`
-        ).to.contain(elementText);
-      } else {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} NOT to contain "${elementText}"`
-        ).to.not.contain(elementText);
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to validate the containment of the text of the element ${elementName}: ${error}`
-      );
-    }
-  }
-);
-
-/**
- * @name assert element equals text
- * @description Template step for validating whether an element text equals a provided text or not
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should {boolean} equal the text {string}',
-  async function (
-    this: CustomWorld,
-    elementName: SelectorName,
-    shouldEqual: boolean,
-    elementText: string
-  ) {
-    try {
-      const selector = await resolveLocator(this.page, elementName);
-      if (!selector) throw new Error(`Selector ${elementName} not found`);
-      const elementTextContent = await this.page
-        .locator(selector)
-        .textContent();
-      if (!elementTextContent)
-        throw new Error(
-          `Element ${elementName} does not have any text content`
-        );
-      if (shouldEqual) {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} to equal "${elementText}"`
-        ).to.equal(elementText);
-      } else {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} NOT to equal "${elementText}"`
-        ).to.not.equal(elementText);
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to validate the equality of the text of the element ${elementName}: ${error}`
-      );
-    }
-  }
-);
-
-/**
- * @name assert element contains stored variable text
- * @description Template step to validate whether an element text contains the text inside a stored variable
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should contain the text inside the stored variable {string}',
-  async function (
-    this: CustomWorld,
-    _elementName: SelectorName,
-    _variableName: string
-  ) {}
-);
+/**
+ * @name text assertion
+ * @description Template steps for asserting text inside elements
+ * @type VALIDATION
+ */
+
+/**
+ * @name assert element contains stored variable text
+ * @description Template step to validate whether an element text contains the text inside a stored variable
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should contain the text inside the stored variable {string}',
+  async function (this: CustomWorld, _elementName: SelectorName, _variableName: string) {},
+)
+
+/**
+ * @name assert element contains text
+ * @description Template step for validating whether an element contains a certain text or not
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should {boolean} contain the text {string}',
+  async function (this: CustomWorld, elementName: SelectorName, shouldContain: boolean, elementText: string) {
+    try {
+      const selector = await resolveLocator(this.page, elementName)
+      if (!selector) throw new Error(`Selector ${elementName} not found`)
+      const elementTextContent = await this.page.locator(selector).textContent()
+
+      if (!elementTextContent) throw new Error(`Element ${elementName} does not have any text content`)
+
+      if (shouldContain) {
+        expect(elementTextContent, `Expected ${elementName} to contain "${elementText}"`).to.contain(elementText)
+      } else {
+        expect(elementTextContent, `Expected ${elementName} NOT to contain "${elementText}"`).to.not.contain(
+          elementText,
+        )
+      }
+    } catch (error) {
+      throw new Error(`Failed to validate the containment of the text of the element ${elementName}: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name assert element equals text
+ * @description Template step for validating whether an element text equals a provided text or not
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should {boolean} equal the text {string}',
+  async function (this: CustomWorld, elementName: SelectorName, shouldEqual: boolean, elementText: string) {
+    try {
+      const selector = await resolveLocator(this.page, elementName)
+      if (!selector) throw new Error(`Selector ${elementName} not found`)
+      const elementTextContent = await this.page.locator(selector).textContent()
+      if (!elementTextContent) throw new Error(`Element ${elementName} does not have any text content`)
+      if (shouldEqual) {
+        expect(elementTextContent, `Expected ${elementName} to equal "${elementText}"`).to.equal(elementText)
+      } else {
+        expect(elementTextContent, `Expected ${elementName} NOT to equal "${elementText}"`).to.not.equal(elementText)
+      }
+    } catch (error) {
+      throw new Error(`Failed to validate the equality of the text of the element ${elementName}: ${error}`)
+    }
+  },
+)

package/templates/starter/automation/steps/validations/visibility_assertion.step.ts

@@ -1,27 +1,25 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name visibility assertion
- * @description Template steps that handles the assertion of element visibility states
- * @type VALIDATION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name assert element visible
- * @description Template step for validating whether an element should be visible or not
- * @icon VALIDATION
- */
-Then(
-  'the visibility status of the {string} element should be {boolean}',
-  async function (this: CustomWorld, elementName: SelectorName, isVisible: boolean) {
-    try {
-      const selector = await resolveLocator(this.page, elementName)
-      if (!selector) throw new Error(`Selector ${elementName} not found`)
-      const elementVisibilityStatus = await this.page.locator(selector).isVisible({ timeout: 10000 })
-      expect(elementVisibilityStatus).to.equal(isVisible)
-    } catch (error) {
-      throw new Error(`Failed to validate the visibility of the element ${elementName}: ${error}`)
-    }
-  },
-)
+/**
+ * @name visibility assertion
+ * @description Template steps that handles the assertion of element visibility states
+ * @type VALIDATION
+ */
+
+/**
+ * @name assert element visible
+ * @description Template step for validating whether an element should be visible or not
+ * @icon VALIDATION
+ */
+Then(
+  'the visibility status of the {string} element should be {boolean}',
+  async function (this: CustomWorld, elementName: SelectorName, isVisible: boolean) {
+    try {
+      const selector = await resolveLocator(this.page, elementName)
+      if (!selector) throw new Error(`Selector ${elementName} not found`)
+      const elementVisibilityStatus = await this.page.locator(selector).isVisible({ timeout: 10000 })
+      expect(elementVisibilityStatus).to.equal(isVisible)
+    } catch (error) {
+      throw new Error(`Failed to validate the visibility of the element ${elementName}: ${error}`)
+    }
+  },
+)

package/templates/starter/components.json

@@ -1,24 +1,24 @@
-{
-  "$schema": "https://ui.shadcn.com/schema.json",
-  "style": "new-york",
-  "rsc": true,
-  "tsx": true,
-  "tailwind": {
-    "config": "tailwind.config.ts",
-    "css": "src/app/globals.css",
-    "baseColor": "slate",
-    "cssVariables": true,
-    "prefix": ""
-  },
-  "iconLibrary": "lucide",
-  "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils",
-    "ui": "@/components/ui",
-    "lib": "@/lib",
-    "hooks": "@/hooks"
-  },
-  "registries": {
-    "@kokonutui": "https://kokonutui.com/r/{name}.json"
-  }
-}
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "src/app/globals.css",
+    "baseColor": "slate",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "registries": {
+    "@kokonutui": "https://kokonutui.com/r/{name}.json"
+  }
+}

package/templates/starter/cucumber.mjs

@@ -1,16 +1,16 @@
-// eslint-disable-next-line import/no-anonymous-default-export
-export default {
-  paths: ['automation/features/**/*.feature'],
-  import: [
-    'packages/cucumber-runtime/src/parameter-types.ts',
-    'automation/steps/**/*.ts',
-    'packages/cucumber-runtime/src/hooks.ts',
-    'packages/cucumber-runtime/src/world.ts',
-  ],
-  loader: ['ts-node/esm'],
-  format: [
-    'pretty',
-    process.env.REPORT_FORMAT ?? `json:${process.env.REPORT_PATH ?? 'automation/reports/cucumber.json'}`,
-  ],
-  publishQuiet: true,
-}
+// eslint-disable-next-line import/no-anonymous-default-export
+export default {
+  paths: ['automation/features/**/*.feature'],
+  import: [
+    'packages/cucumber-runtime/src/parameter-types.ts',
+    'automation/steps/**/*.ts',
+    'packages/cucumber-runtime/src/hooks.ts',
+    'packages/cucumber-runtime/src/world.ts',
+  ],
+  loader: ['ts-node/esm'],
+  format: [
+    'pretty',
+    process.env.REPORT_FORMAT ?? `json:${process.env.REPORT_PATH ?? 'automation/reports/cucumber.json'}`,
+  ],
+  publishQuiet: true,
+}

package/templates/starter/e2e/README.md

@@ -0,0 +1,56 @@
+# AppraiseJS E2E tests
+
+Playwright UI tests run against a local Next.js server with an isolated SQLite database. Data is reset and seeded before each test via Prisma helpers in `e2e/helpers/test-data.ts`.
+
+## Commands
+
+- `npm run validate:e2e` — full suite (used in CI)
+- `npm run validate:e2e:smoke` — smoke gate only (`@smoke` tag)
+- `E2E_GREP=@crud npx playwright test` — run a tagged subset locally
+
+## CI and parallelism
+
+GitHub Actions runs `npm run validate:e2e` after `npm run build` with `DATABASE_URL=file:./e2e.db`
+and `CI=true`. The Playwright web server starts via `e2e/start-server.mjs`, which recreates the
+E2E database and applies migrations before serving the production build.
+
+Keep `workers: 1` and `fullyParallel: false` in `playwright.config.ts` until each worker gets an
+isolated database. Spec files reset and seed the same SQLite file in `beforeEach`, so parallel
+workers cause unique-constraint and foreign-key failures in CI and locally.
+
+## Layout
+
+| File | Purpose |
+| --- | --- |
+| `appraise-smoke.spec.ts` | Fast regression gate |
+| `navigation.spec.ts` | Route matrix and dashboard attention links |
+| `crud-configuration.spec.ts` | Configuration entity CRUD |
+| `crud-tests.spec.ts` | Suites, cases, template-based create |
+| `authoring.spec.ts` | Inline dialogs, flow panel, authoring |
+| `runs-and-reports.spec.ts` | Seeded runs, reports, create form (no execution) |
+| `settings-sync.spec.ts` | Per-script sync buttons |
+
+Helpers live under `e2e/helpers/` (`ui`, `navigation`, `table`, `forms`, `test-data`).
+
+## Seed model
+
+`seedCoreData()` provisions modules, environments, tags, locators, template steps, a test case and suite, a completed run with report, and dashboard metric variants (failed, queued, running runs; attention metrics for drawer links).
+
+Seeded IDs are exported as `seededIds` for deep-link tests.
+
+## Scope boundaries
+
+**In scope:** UI flows with deterministic Prisma seed data.
+
+**Out of scope (covered elsewhere):**
+
+- Live `cucumber-js` execution and report JSON ingestion during E2E
+- Locator picker companion / external browser extension flows
+- Bidirectional feature sync CLI unless exposed in Settings UI
+
+## Debugging
+
+- Traces: `trace: 'on-first-retry'` in `playwright.config.ts`
+- Videos/screenshots retained on failure
+- Run a single file: `npx playwright test e2e/navigation.spec.ts`
+- UI mode: `npx playwright test --ui`

package/templates/starter/e2e/apply-migrations.mjs

@@ -0,0 +1,76 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { isAbsolute, join, resolve } from 'node:path'
+import { DatabaseSync } from 'node:sqlite'
+
+function sqlitePathFromDatabaseUrl(value) {
+  if (!value?.startsWith('file:')) {
+    throw new Error(`E2E SQLite setup expects a file: DATABASE_URL, received ${value || '<empty>'}`)
+  }
+
+  const sqlitePath = value.replace(/^file:/, '')
+  return isAbsolute(sqlitePath) ? sqlitePath : resolve(process.cwd(), 'prisma', sqlitePath)
+}
+
+const databaseUrl = process.env.DATABASE_URL ?? 'file:./e2e.db'
+const databasePath = sqlitePathFromDatabaseUrl(databaseUrl)
+const migrationsDir = resolve(process.cwd(), 'prisma', 'migrations')
+const db = new DatabaseSync(databasePath)
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS "_prisma_migrations" (
+    "id"                    TEXT PRIMARY KEY NOT NULL,
+    "checksum"              TEXT NOT NULL,
+    "finished_at"           DATETIME,
+    "migration_name"        TEXT NOT NULL,
+    "logs"                  TEXT,
+    "rolled_back_at"        DATETIME,
+    "started_at"            DATETIME NOT NULL DEFAULT current_timestamp,
+    "applied_steps_count"   INTEGER UNSIGNED NOT NULL DEFAULT 0
+  );
+`)
+
+const appliedRows = db.prepare('SELECT migration_name FROM "_prisma_migrations"').all()
+const appliedMigrations = new Set(appliedRows.map(row => row.migration_name))
+const insertMigration = db.prepare(`
+  INSERT INTO "_prisma_migrations" (
+    id,
+    checksum,
+    finished_at,
+    migration_name,
+    logs,
+    rolled_back_at,
+    applied_steps_count
+  ) VALUES (?, ?, current_timestamp, ?, NULL, NULL, 1)
+`)
+
+const migrationNames = readdirSync(migrationsDir, { withFileTypes: true })
+  .filter(entry => entry.isDirectory())
+  .map(entry => entry.name)
+  .sort()
+
+for (const migrationName of migrationNames) {
+  if (appliedMigrations.has(migrationName)) {
+    continue
+  }
+
+  const migrationPath = join(migrationsDir, migrationName, 'migration.sql')
+  if (!existsSync(migrationPath)) {
+    continue
+  }
+
+  const sql = readFileSync(migrationPath, 'utf8')
+  const checksum = createHash('sha256').update(sql).digest('hex')
+
+  db.exec('BEGIN')
+  try {
+    db.exec(sql)
+    insertMigration.run(randomUUID(), checksum, migrationName)
+    db.exec('COMMIT')
+  } catch (error) {
+    db.exec('ROLLBACK')
+    throw error
+  }
+}
+
+db.close()

package/templates/starter/e2e/appraise-smoke.spec.ts

@@ -0,0 +1,78 @@
+import { test, expect } from '@playwright/test'
+
+import {
+  disconnectPrisma,
+  findModuleByName,
+  generateSeededFeature,
+  readGeneratedFeature,
+  resetE2eData,
+  seedCoreData,
+  seededIds,
+} from './helpers/test-data'
+import { createModule, expectPageHeading } from './helpers/ui'
+
+test.describe('Smoke @smoke', () => {
+  test.beforeEach(async () => {
+    await resetE2eData()
+    await seedCoreData()
+  })
+
+  test.afterAll(async () => {
+    await disconnectPrisma()
+  })
+
+  test('dashboard renders seeded entity metrics', async ({ page }) => {
+    await page.goto('/')
+    await expectPageHeading(page, 'Dashboard')
+    await expect(page.getByText('Test Cases')).toBeVisible()
+    await expect(page.getByText('Test Suites')).toBeVisible()
+    await expect(page.getByText('Template Steps')).toBeVisible()
+    await expect(page.getByText('Attention Needed')).toBeVisible()
+  })
+
+  test('module CRUD path creates edits and deletes a module', async ({ page }) => {
+    const moduleName = 'E2E Smoke Module'
+    const editedModuleName = 'E2E Smoke Module Edited'
+
+    await createModule(page, moduleName)
+    const createdModule = await findModuleByName(moduleName)
+    expect(createdModule).not.toBeNull()
+
+    await page.goto(`/modules/modify/${createdModule?.id}`)
+    await page.getByLabel('Name').fill(editedModuleName)
+    await page.getByRole('button', { name: /^Save$/ }).click()
+    await expect(page).toHaveURL(/\/modules$/)
+    await expect(page.getByText(editedModuleName, { exact: true }).first()).toBeVisible()
+  })
+
+  test('seeded completed run opens report summary', async ({ page }) => {
+    await page.goto(`/test-runs/${seededIds.testRun}`)
+    await expectPageHeading(page, 'Test Run Details')
+    await expect(page.getByText('E2E Completed Run')).toBeVisible()
+
+    await page.getByRole('link', { name: /View Report/ }).click()
+    await expectPageHeading(page, /Test Run Report:/)
+    await expect(page.getByText('E2E seeded login works')).toBeVisible()
+  })
+
+  test('settings sync all completes without a fatal error', async ({ page }) => {
+    test.setTimeout(120_000)
+
+    await page.goto('/settings')
+    await expectPageHeading(page, 'Settings')
+    await page.getByRole('button', { name: 'Sync All' }).click()
+    await expect(page.getByText(/Sync completed|Sync failed/).first()).toBeVisible({ timeout: 90_000 })
+    await expect(page.getByText(/fatal|uncaught/i)).toHaveCount(0)
+  })
+
+  test('feature generation writes suite-backed feature output', async () => {
+    const featurePath = await generateSeededFeature()
+    const featureContent = readGeneratedFeature()
+
+    expect(featurePath.replaceAll('\\', '/')).toContain('automation/features/E2E Auth/e2e-auth-suite.feature')
+    expect(featureContent).toContain('Feature: Seeded suite for E2E feature generation')
+    expect(featureContent).toContain('@e2e-smoke')
+    expect(featureContent).toContain('Scenario: [E2E seeded login works] Seeded login smoke case')
+    expect(featureContent).toContain('Given I open the seeded page')
+  })
+})

package/templates/starter/e2e/authoring.spec.ts

@@ -0,0 +1,53 @@
+import { test, expect } from '@playwright/test'
+
+import { disconnectPrisma, resetE2eData, seedCoreData, seededIds } from './helpers/test-data'
+import { createTestCaseWithSeededStep } from './helpers/forms'
+import { expectPageHeading } from './helpers/ui'
+
+test.describe('Test authoring @authoring', () => {
+  test.beforeEach(async () => {
+    await resetE2eData()
+    await seedCoreData()
+  })
+
+  test.afterAll(async () => {
+    await disconnectPrisma()
+  })
+
+  test('inline tag and test suite dialogs add selectable records', async ({ page }) => {
+    await page.goto('/test-cases/create')
+    await expectPageHeading(page, 'Create New Test Case')
+    await page.getByRole('textbox', { name: 'Title' }).fill('E2E Inline Dialog Case')
+
+    await page.getByRole('button', { name: 'Create filter tag' }).click()
+    await page.getByRole('textbox', { name: 'Name', exact: true }).fill('E2E Inline Tag')
+    await page.getByRole('textbox', { name: 'Tag Expression', exact: true }).fill('@e2e-inline')
+    await page.getByRole('button', { name: /^Save$/ }).click()
+    await expect(page.getByRole('button', { name: 'E2E Inline Tag' })).toBeVisible()
+
+    await page.getByRole('button', { name: 'Create test suite' }).click()
+    await page.getByLabel('Name').fill('E2E Inline Suite')
+    await page.getByLabel('Module').click()
+    await page.getByRole('option', { name: 'E2E Auth' }).click()
+    await page.getByRole('button', { name: /^Save$/ }).click()
+    await expect(page.getByRole('button', { name: 'E2E Inline Suite' })).toBeVisible()
+  })
+
+  test('flow panel mounts on modify page and scenario preview shows seeded steps', async ({ page }) => {
+    await page.goto(`/test-cases/modify/${seededIds.testCase}`)
+    await expectPageHeading(page, 'Modify Test Case')
+    await page.getByRole('button', { name: /Continue/ }).click()
+    await expect(page.getByText('Test Case Flow', { exact: true }).first()).toBeVisible()
+    await expect(page.getByRole('button', { name: 'Search nodes' })).toBeVisible()
+
+    await page.getByRole('button', { name: 'Show test scenario preview' }).click()
+    await expect(page.getByText('Test Scenario(Preview)')).toBeVisible()
+    await expect(page.getByText('Given I open the seeded page')).toBeVisible()
+  })
+
+  test('full create flow adds a template-backed step before saving', async ({ page }) => {
+    await createTestCaseWithSeededStep(page, 'E2E Authored Case')
+    await page.goto('/test-cases')
+    await expect(page.getByText('E2E Authored Case', { exact: true }).first()).toBeVisible()
+  })
+})