create-appraisejs 0.1.10-alpha.8 → 0.2.0-alpha.1

package/templates/default/package.json

@@ -7,6 +7,7 @@
     "dev": "next dev",
     "init": "DISABLE_DEVTOOLS=1 NEXT_PUBLIC_DISABLE_DEVTOOLS=1 next dev",
     "build:cucumber-runtime": "tsc -p packages/cucumber-runtime/tsconfig.json",
+    "build:locator-picker-companion": "tsc -p packages/locator-picker-companion/tsconfig.json",
     "build": "npm run build:local",
     "start": "next start",
     "lint": "eslint .",
@@ -29,7 +30,7 @@
     "sync-all": "npx tsx scripts/sync-all.ts",
     "sync-template": "npx tsx scripts/sync-appraise-base-template.ts",
     "test": "cucumber-js",
-    "build:local": "npm run generate-db-client && npm run build:cucumber-runtime && next build",
+    "build:local": "npm run generate-db-client && npm run build:cucumber-runtime && npm run build:locator-picker-companion && next build",
     "generate-db-client": "npx prisma generate --schema prisma/schema.prisma",
     "setup:db": "npm run setup-env && npm run generate-db-client && npm run migrate-db && npm run sync-all",
     "setup:full": "npm run install-dependencies && npm run setup:db && npm run build:local && npm run protect-seeded-files",

package/templates/default/packages/cucumber-runtime/package.json

@@ -1,13 +1,13 @@
-{
-  "name": "@appraise/cucumber-runtime",
-  "private": true,
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json"
-  }
-}
+{
+  "name": "@appraise/cucumber-runtime",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}

package/templates/default/packages/cucumber-runtime/src/cache.util.ts

@@ -1,93 +1,93 @@
-import { readFileSync } from 'fs'
-import { globSync } from 'glob'
-import * as path from 'path'
-import { LocatorCollection, LocatorMap } from './types.js'
-import { getAutomationLocatorMapPath, getAutomationLocatorsDir } from './paths.js'
-
-function toGlobPath(targetPath: string): string {
-  return targetPath.split(path.sep).join('/')
-}
-
-export class LocatorCache {
-  private static instance: LocatorCache
-  private data: Record<string, LocatorCollection> = {}
-  private filePaths: Record<string, string> = {}
-  private loadedFiles: Set<string> = new Set()
-
-  private constructor() {
-    globSync(`${toGlobPath(getAutomationLocatorsDir())}/**/*.json`).forEach(file => {
-      const fileName = path.basename(file, path.extname(file))
-      this.filePaths[fileName ?? file] = file
-    })
-  }
-
-  public static getInstance(): LocatorCache {
-    if (!LocatorCache.instance) {
-      LocatorCache.instance = new LocatorCache()
-    }
-    return LocatorCache.instance
-  }
-
-  public get(key: string): LocatorCollection | null {
-    if (!this.loadedFiles.has(key) && this.filePaths[key]) {
-      try {
-        const filePath = this.filePaths[key]
-        const data = JSON.parse(readFileSync(filePath, 'utf8'))
-        this.data[key] = data as LocatorCollection
-        this.loadedFiles.add(key)
-      } catch (error) {
-        console.error(`Error loading locator file for key "${key}":`, error)
-        return null
-      }
-    }
-
-    return this.data[key] ? { ...this.data[key] } : null
-  }
-
-  public preloadAll(): void {
-    Object.keys(this.filePaths).forEach(key => {
-      if (!this.loadedFiles.has(key)) {
-        this.get(key)
-      }
-    })
-  }
-
-  public getAvailableKeys(): string[] {
-    return Object.keys(this.filePaths)
-  }
-
-  public isLoaded(key: string): boolean {
-    return this.loadedFiles.has(key)
-  }
-}
-
-export class LocatorMapCache {
-  private static instance: LocatorMapCache
-  private data: LocatorMap[] = []
-
-  private constructor() {
-    this.data = JSON.parse(readFileSync(getAutomationLocatorMapPath(), 'utf8'))
-  }
-
-  public static getInstance(): LocatorMapCache {
-    if (!LocatorMapCache.instance) {
-      LocatorMapCache.instance = new LocatorMapCache()
-    }
-    return LocatorMapCache.instance
-  }
-
-  public get(key: string): LocatorMap {
-    try {
-      return this.data.find(map => map.path === key) as LocatorMap
-    } catch {
-      return {
-        name: '',
-        path: '',
-      }
-    }
-  }
-
-  public getAll(): LocatorMap[] {
-    return this.data
-  }
-}
+import { readFileSync } from 'fs'
+import { globSync } from 'glob'
+import * as path from 'path'
+import { LocatorCollection, LocatorMap } from './types.js'
+import { getAutomationLocatorMapPath, getAutomationLocatorsDir } from './paths.js'
+
+function toGlobPath(targetPath: string): string {
+  return targetPath.split(path.sep).join('/')
+}
+
+export class LocatorCache {
+  private static instance: LocatorCache
+  private data: Record<string, LocatorCollection> = {}
+  private filePaths: Record<string, string> = {}
+  private loadedFiles: Set<string> = new Set()
+
+  private constructor() {
+    globSync(`${toGlobPath(getAutomationLocatorsDir())}/**/*.json`).forEach(file => {
+      const fileName = path.basename(file, path.extname(file))
+      this.filePaths[fileName ?? file] = file
+    })
+  }
+
+  public static getInstance(): LocatorCache {
+    if (!LocatorCache.instance) {
+      LocatorCache.instance = new LocatorCache()
+    }
+    return LocatorCache.instance
+  }
+
+  public get(key: string): LocatorCollection | null {
+    if (!this.loadedFiles.has(key) && this.filePaths[key]) {
+      try {
+        const filePath = this.filePaths[key]
+        const data = JSON.parse(readFileSync(filePath, 'utf8'))
+        this.data[key] = data as LocatorCollection
+        this.loadedFiles.add(key)
+      } catch (error) {
+        console.error(`Error loading locator file for key "${key}":`, error)
+        return null
+      }
+    }
+
+    return this.data[key] ? { ...this.data[key] } : null
+  }
+
+  public preloadAll(): void {
+    Object.keys(this.filePaths).forEach(key => {
+      if (!this.loadedFiles.has(key)) {
+        this.get(key)
+      }
+    })
+  }
+
+  public getAvailableKeys(): string[] {
+    return Object.keys(this.filePaths)
+  }
+
+  public isLoaded(key: string): boolean {
+    return this.loadedFiles.has(key)
+  }
+}
+
+export class LocatorMapCache {
+  private static instance: LocatorMapCache
+  private data: LocatorMap[] = []
+
+  private constructor() {
+    this.data = JSON.parse(readFileSync(getAutomationLocatorMapPath(), 'utf8'))
+  }
+
+  public static getInstance(): LocatorMapCache {
+    if (!LocatorMapCache.instance) {
+      LocatorMapCache.instance = new LocatorMapCache()
+    }
+    return LocatorMapCache.instance
+  }
+
+  public get(key: string): LocatorMap {
+    try {
+      return this.data.find(map => map.path === key) as LocatorMap
+    } catch {
+      return {
+        name: '',
+        path: '',
+      }
+    }
+  }
+
+  public getAll(): LocatorMap[] {
+    return this.data
+  }
+}

package/templates/default/packages/cucumber-runtime/src/cli.ts

@@ -1,68 +1,68 @@
-import { Command, Option, OptionValues } from 'commander'
-import parseTagExpression from '@cucumber/tag-expressions'
-import { getAllEnvironments } from './environment.util.js'
-import { BrowserName } from './types.js'
-
-export interface CliOptions extends OptionValues {
-  environment: string
-  tags: string
-  parallel: number
-  browser: BrowserName
-  headless: 'true' | 'false'
-}
-
-const BROWSER_CHOICES = ['chromium', 'firefox', 'webkit'] as const
-const HEADLESS_CHOICES = ['true', 'false'] as const
-const DEFAULT_PARALLEL_WORKERS = 1
-const DEFAULT_BROWSER: BrowserName = 'chromium'
-const DEFAULT_HEADLESS = 'true'
-
-const program = new Command()
-
-let environmentNames: string[] = []
-try {
-  environmentNames = Object.keys(getAllEnvironments())
-} catch (error) {
-  console.error('Failed to load environments:', error instanceof Error ? error.message : 'Unknown error')
-  process.exit(1)
-}
-
-function parsePositiveInt(value: string): number {
-  const parsed = Number(value)
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error(`--parallel must be a positive integer, got "${value}"`)
-  }
-  return parsed
-}
-
-function validateCucumberTagExpression(value: string): string {
-  try {
-    parseTagExpression(value)
-    return value
-  } catch (error) {
-    throw new Error(`Invalid tag expression: ${error instanceof Error ? error.message : 'Unknown error'}`)
-  }
-}
-
-program
-  .name('cucumber-runtime')
-  .description('CLI for running Appraise cucumber automation')
-  .version('1.0.0')
-  .addOption(
-    new Option('-e, --environment <environment>', 'The environment to run the tests on')
-      .choices(environmentNames)
-      .makeOptionMandatory(),
-  )
-  .addOption(
-    new Option('-t, --tags <tags>', 'The tags to run the tests on')
-      .argParser(validateCucumberTagExpression)
-      .makeOptionMandatory(),
-  )
-  .option('-p, --parallel <parallel>', 'The number of parallel workers to run', parsePositiveInt, DEFAULT_PARALLEL_WORKERS)
-  .addOption(new Option('-b, --browser <browser>', 'The browser to run').choices(BROWSER_CHOICES).default(DEFAULT_BROWSER))
-  .addOption(new Option('--headless <headless>', 'Whether to run headless').choices(HEADLESS_CHOICES).default(DEFAULT_HEADLESS))
-
-export function startCli(): CliOptions {
-  program.parse()
-  return program.opts() as CliOptions
-}
+import { Command, Option, OptionValues } from 'commander'
+import parseTagExpression from '@cucumber/tag-expressions'
+import { getAllEnvironments } from './environment.util.js'
+import { BrowserName } from './types.js'
+
+export interface CliOptions extends OptionValues {
+  environment: string
+  tags: string
+  parallel: number
+  browser: BrowserName
+  headless: 'true' | 'false'
+}
+
+const BROWSER_CHOICES = ['chromium', 'firefox', 'webkit'] as const
+const HEADLESS_CHOICES = ['true', 'false'] as const
+const DEFAULT_PARALLEL_WORKERS = 1
+const DEFAULT_BROWSER: BrowserName = 'chromium'
+const DEFAULT_HEADLESS = 'true'
+
+const program = new Command()
+
+let environmentNames: string[] = []
+try {
+  environmentNames = Object.keys(getAllEnvironments())
+} catch (error) {
+  console.error('Failed to load environments:', error instanceof Error ? error.message : 'Unknown error')
+  process.exit(1)
+}
+
+function parsePositiveInt(value: string): number {
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`--parallel must be a positive integer, got "${value}"`)
+  }
+  return parsed
+}
+
+function validateCucumberTagExpression(value: string): string {
+  try {
+    parseTagExpression(value)
+    return value
+  } catch (error) {
+    throw new Error(`Invalid tag expression: ${error instanceof Error ? error.message : 'Unknown error'}`)
+  }
+}
+
+program
+  .name('cucumber-runtime')
+  .description('CLI for running Appraise cucumber automation')
+  .version('1.0.0')
+  .addOption(
+    new Option('-e, --environment <environment>', 'The environment to run the tests on')
+      .choices(environmentNames)
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-t, --tags <tags>', 'The tags to run the tests on')
+      .argParser(validateCucumberTagExpression)
+      .makeOptionMandatory(),
+  )
+  .option('-p, --parallel <parallel>', 'The number of parallel workers to run', parsePositiveInt, DEFAULT_PARALLEL_WORKERS)
+  .addOption(new Option('-b, --browser <browser>', 'The browser to run').choices(BROWSER_CHOICES).default(DEFAULT_BROWSER))
+  .addOption(new Option('--headless <headless>', 'Whether to run headless').choices(HEADLESS_CHOICES).default(DEFAULT_HEADLESS))
+
+export function startCli(): CliOptions {
+  program.parse()
+  return program.opts() as CliOptions
+}

package/templates/default/packages/cucumber-runtime/src/environment.util.ts

@@ -1,21 +1,21 @@
-import { readFileSync } from 'fs'
-import { getAutomationEnvironmentsFilePath } from './paths.js'
-
-interface EnvironmentConfig {
-  baseUrl: string
-  apiBaseUrl: string
-  email: string
-  password: string
-}
-
-export function getEnvironment(environment: string): EnvironmentConfig {
-  const environmentConfig: Record<string, EnvironmentConfig> = JSON.parse(
-    readFileSync(getAutomationEnvironmentsFilePath(), 'utf8'),
-  )
-
-  return environmentConfig[environment.toLowerCase()] as EnvironmentConfig
-}
-
-export function getAllEnvironments(): Record<string, EnvironmentConfig> {
-  return JSON.parse(readFileSync(getAutomationEnvironmentsFilePath(), 'utf8'))
-}
+import { readFileSync } from 'fs'
+import { getAutomationEnvironmentsFilePath } from './paths.js'
+
+interface EnvironmentConfig {
+  baseUrl: string
+  apiBaseUrl: string
+  email: string
+  password: string
+}
+
+export function getEnvironment(environment: string): EnvironmentConfig {
+  const environmentConfig: Record<string, EnvironmentConfig> = JSON.parse(
+    readFileSync(getAutomationEnvironmentsFilePath(), 'utf8'),
+  )
+
+  return environmentConfig[environment.toLowerCase()] as EnvironmentConfig
+}
+
+export function getAllEnvironments(): Record<string, EnvironmentConfig> {
+  return JSON.parse(readFileSync(getAutomationEnvironmentsFilePath(), 'utf8'))
+}

package/templates/default/packages/cucumber-runtime/src/executor.ts

@@ -1,32 +1,32 @@
-import { execa } from 'execa'
-import { config } from 'dotenv'
-import { startCli } from './cli.js'
-
-async function bootstrap(): Promise<void> {
-  config()
-
-  try {
-    const { environment, tags, parallel, browser, headless } = startCli()
-
-    process.env.ENVIRONMENT = environment
-    process.env.HEADLESS = headless
-    process.env.BROWSER = browser
-
-    const cucumberArgs: string[] = ['cucumber-js', '-t', tags]
-    if (parallel > 1) {
-      cucumberArgs.push('--parallel', parallel.toString())
-    }
-
-    const subprocess = execa('npx', cucumberArgs, {
-      stdio: 'inherit',
-    })
-
-    const result = await subprocess
-    process.exit(result.exitCode ?? 0)
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : 'Unknown error')
-    process.exit(1)
-  }
-}
-
-bootstrap()
+import { execa } from 'execa'
+import { config } from 'dotenv'
+import { startCli } from './cli.js'
+
+async function bootstrap(): Promise<void> {
+  config()
+
+  try {
+    const { environment, tags, parallel, browser, headless } = startCli()
+
+    process.env.ENVIRONMENT = environment
+    process.env.HEADLESS = headless
+    process.env.BROWSER = browser
+
+    const cucumberArgs: string[] = ['cucumber-js', '-t', tags]
+    if (parallel > 1) {
+      cucumberArgs.push('--parallel', parallel.toString())
+    }
+
+    const subprocess = execa('npx', cucumberArgs, {
+      stdio: 'inherit',
+    })
+
+    const result = await subprocess
+    process.exit(result.exitCode ?? 0)
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : 'Unknown error')
+    process.exit(1)
+  }
+}
+
+bootstrap()

package/templates/default/packages/cucumber-runtime/src/hooks.ts

@@ -2,12 +2,13 @@ import { After, AfterAll, AfterStep, Before, BeforeAll, setDefaultTimeout } from
 import { config } from 'dotenv'
 import { promises as fs } from 'fs'
 import { chromium, firefox, webkit, ChromiumBrowser, FirefoxBrowser, WebKitBrowser } from 'playwright'
-import { getAutomationTraceDir } from './paths.js'
+import { getAutomationScreenshotDir, getAutomationTraceDir, toProjectRelativePath } from './paths.js'
 import { BrowserName } from './types.js'
 import { CustomWorld } from './world.js'
 
 config()
 
+const SCREENSHOT_ATTACHMENT_MEDIA_TYPE = 'application/vnd.appraisejs.report-step-screenshot+json'
 let browser: ChromiumBrowser | FirefoxBrowser | WebKitBrowser
 let currentScenarioStatus = 'unknown'
 
@@ -45,6 +46,24 @@ AfterStep(async function (this: CustomWorld, result) {
   const status = result.result?.status
   if (status === 'FAILED') {
     currentScenarioStatus = 'failed'
+
+    if (result.pickleStep?.text) {
+      try {
+        const screenshotDir = getAutomationScreenshotDir()
+        await fs.mkdir(screenshotDir, { recursive: true })
+
+        const screenshotPath = `${screenshotDir}/${crypto.randomUUID()}.png`
+        await this.page.screenshot({ path: screenshotPath, fullPage: true })
+        await this.attach(
+          JSON.stringify({ screenshotPath: toProjectRelativePath(screenshotPath) }),
+          SCREENSHOT_ATTACHMENT_MEDIA_TYPE,
+        )
+      } catch (error) {
+        console.warn(
+          `[CucumberRuntime] Failed to capture screenshot for step "${result.pickleStep.text}": ${error instanceof Error ? error.message : 'Unknown error'}`,
+        )
+      }
+    }
   } else if (status === 'SKIPPED' && currentScenarioStatus !== 'failed') {
     currentScenarioStatus = 'skipped'
   } else if (status === 'PASSED' && currentScenarioStatus === 'unknown') {
@@ -57,14 +76,17 @@ After(async function (this: CustomWorld, scenario) {
   if (scenario.result?.status === 'FAILED') {
     const traceDir = getAutomationTraceDir()
     await fs.mkdir(traceDir, { recursive: true })
-    tracePath = `${traceDir}/${crypto.randomUUID()}.zip`
-    await this.context.tracing.stop({ path: tracePath })
+    const absoluteTracePath = `${traceDir}/${crypto.randomUUID()}.zip`
+    tracePath = toProjectRelativePath(absoluteTracePath)
+    await this.context.tracing.stop({ path: absoluteTracePath })
   }
 
   const eventJson = JSON.stringify({
     event: 'scenario::end',
     data: {
+      featureName: scenario.gherkinDocument?.feature?.name,
       scenarioName: scenario.pickle.name,
+      scenarioTags: scenario.pickle.tags?.map(tag => tag.name) ?? [],
       status: currentScenarioStatus,
       tracePath,
     },

package/templates/default/packages/cucumber-runtime/src/index.ts

@@ -1,17 +1,17 @@
-export {
-  After,
-  AfterAll,
-  AfterStep,
-  Before,
-  BeforeAll,
-  Given,
-  Then,
-  When,
-  defineParameterType,
-  setDefaultTimeout,
-} from '@cucumber/cucumber'
-export { CustomWorld, expect } from './world.js'
-export { getEnvironment, getAllEnvironments } from './environment.util.js'
-export { resolveLocator, retry, waitForRouteSettled } from './locator.util.js'
-export { generateRandomData, RandomDataType } from './random-data.util.js'
-export type { BrowserName, Locator, LocatorCollection, LocatorMap, Selector, SelectorName } from './types.js'
+export {
+  After,
+  AfterAll,
+  AfterStep,
+  Before,
+  BeforeAll,
+  Given,
+  Then,
+  When,
+  defineParameterType,
+  setDefaultTimeout,
+} from '@cucumber/cucumber'
+export { CustomWorld, expect } from './world.js'
+export { getEnvironment, getAllEnvironments } from './environment.util.js'
+export { resolveLocator, retry, waitForRouteSettled } from './locator.util.js'
+export { generateRandomData, RandomDataType } from './random-data.util.js'
+export type { BrowserName, Locator, LocatorCollection, LocatorMap, Selector, SelectorName } from './types.js'