create-appraisejs 0.1.9 → 0.1.10-alpha.0

package/templates/default/src/lib/executor/local-executor-adapter.ts

@@ -0,0 +1,101 @@
+import { join } from 'path'
+import { spawnTask, taskSpawner, type SpawnedProcess, waitForTask, killTask } from '@/lib/process/task-spawner'
+import { ensureAutomationWorkspaceReady, getAutomationReportsDir } from '@/lib/automation/paths'
+import type { ExecutorAdapter, TestRunExecutionRequest, TestRunExecutionResult } from './types'
+import { processManager } from '@/lib/test-run/process-manager'
+
+function mapBrowserEngineToName(browserEngine: TestRunExecutionRequest['browserEngine']): 'chromium' | 'firefox' | 'webkit' {
+  switch (browserEngine) {
+    case 'CHROMIUM':
+      return 'chromium'
+    case 'FIREFOX':
+      return 'firefox'
+    case 'WEBKIT':
+      return 'webkit'
+    default:
+      return 'chromium'
+  }
+}
+
+function combineTagExpressions(tags: TestRunExecutionRequest['tags']): string | null {
+  if (tags.length === 0) {
+    return null
+  }
+
+  if (tags.length === 1) {
+    return tags[0].tagExpression
+  }
+
+  return tags.map(tag => `(${tag.tagExpression})`).join(' or ')
+}
+
+function generateReportPath(testRunId: string): string {
+  const timestamp = Date.now()
+  return join(getAutomationReportsDir(), `cucumber-${testRunId}-${timestamp}.json`)
+}
+
+export class LocalExecutorAdapter implements ExecutorAdapter {
+  async executeTestRun(config: TestRunExecutionRequest): Promise<TestRunExecutionResult> {
+    await ensureAutomationWorkspaceReady()
+
+    const { testRunId, environment, tags, testWorkersCount, browserEngine, headless = true } = config
+    const reportPath = generateReportPath(testRunId)
+    const browserName = mapBrowserEngineToName(browserEngine)
+
+    process.env.ENVIRONMENT = environment.name
+    process.env.HEADLESS = headless.toString()
+    process.env.BROWSER = browserName
+    process.env.REPORT_PATH = reportPath
+
+    const cucumberArgs: string[] = ['cucumber-js']
+    const tagExpression = combineTagExpressions(tags)
+
+    if (tagExpression) {
+      cucumberArgs.push('-t', tagExpression)
+    }
+
+    if (testWorkersCount > 1) {
+      cucumberArgs.push('--parallel', testWorkersCount.toString())
+    }
+
+    const spawnedProcess = await spawnTask('npx', cucumberArgs, {
+      streamLogs: true,
+      prefixLogs: true,
+      logPrefix: `test-run-${testRunId}`,
+      captureOutput: true,
+    })
+
+    processManager.register(testRunId, spawnedProcess)
+    spawnedProcess.process.on('exit', () => {
+      processManager.unregister(testRunId)
+    })
+
+    return {
+      process: spawnedProcess,
+      reportPath,
+    }
+  }
+
+  waitForProcess(processName: string): Promise<number | null> {
+    return waitForTask(processName)
+  }
+
+  killProcess(processName: string, signal?: NodeJS.Signals): boolean {
+    return killTask(processName, signal)
+  }
+
+  getProcess(processName: string): SpawnedProcess | undefined {
+    return taskSpawner.getProcess(processName)
+  }
+
+  spawnTraceViewer(testCaseId: string, tracePath: string): Promise<SpawnedProcess> {
+    return taskSpawner.spawn('npx', ['playwright', 'show-trace', tracePath], {
+      streamLogs: true,
+      prefixLogs: true,
+      logPrefix: `trace-viewer-${testCaseId}`,
+      captureOutput: false,
+    })
+  }
+}
+
+export const localExecutorAdapter = new LocalExecutorAdapter()

package/templates/default/src/lib/executor/types.ts

@@ -0,0 +1,24 @@
+import type { BrowserEngine, Environment, Tag } from '@prisma/client'
+import type { SpawnedProcess } from '@/lib/process/task-spawner'
+
+export interface TestRunExecutionRequest {
+  testRunId: string
+  environment: Environment
+  tags: Tag[]
+  testWorkersCount: number
+  browserEngine: BrowserEngine
+  headless?: boolean
+}
+
+export interface TestRunExecutionResult {
+  process: SpawnedProcess
+  reportPath: string
+}
+
+export interface ExecutorAdapter {
+  executeTestRun(config: TestRunExecutionRequest): Promise<TestRunExecutionResult>
+  waitForProcess(processName: string): Promise<number | null>
+  killProcess(processName: string, signal?: NodeJS.Signals): boolean
+  getProcess(processName: string): SpawnedProcess | undefined
+  spawnTraceViewer(testCaseId: string, tracePath: string): Promise<SpawnedProcess>
+}

package/templates/default/src/lib/feature-file-generator.ts

@@ -2,68 +2,41 @@ import { promises as fs } from 'fs'
 import { join, dirname } from 'path'
 import prisma from '@/config/db-config'
 import { buildModulePath } from '@/lib/path-helpers/module-path'
+import { ensureAutomationWorkspaceReady, getAutomationFeaturesDir } from '@/lib/automation/paths'
 
-/**
- * Checks if a directory is empty (no files or subdirectories)
- * @param dirPath - Path to the directory to check
- * @returns Promise<boolean> - True if directory is empty, false otherwise
- */
 async function isDirectoryEmpty(dirPath: string): Promise<boolean> {
   try {
     const entries = await fs.readdir(dirPath)
     return entries.length === 0
-  } catch (error) {
-    // If directory doesn't exist or can't be read, consider it empty
-    console.warn(`Could not read directory ${dirPath}:`, error)
+  } catch {
     return true
   }
 }
 
-/**
- * Removes empty directories up the hierarchy until a non-empty directory is found
- * @param dirPath - Starting directory path to clean up
- * @param basePath - Base path to stop cleaning (e.g., features directory)
- * @returns Promise<void>
- */
 async function removeEmptyDirectoriesUp(dirPath: string, basePath: string): Promise<void> {
   let currentPath = dirPath
 
-  // Keep going up the directory tree until we reach the base path
   while (currentPath !== basePath && currentPath !== dirname(currentPath)) {
     try {
-      // Check if current directory is empty
       if (await isDirectoryEmpty(currentPath)) {
         await fs.rmdir(currentPath)
-        console.log(`Removed empty directory: ${currentPath}`)
-        // Move up one level
         currentPath = dirname(currentPath)
       } else {
-        // Directory is not empty, stop cleaning
         break
       }
-    } catch (error) {
-      // If we can't remove the directory or it doesn't exist, stop
-      console.warn(`Could not remove directory ${currentPath}:`, error)
+    } catch {
       break
     }
   }
 }
 
-/**
- * Generates a Gherkin feature file for a test suite
- * @param testSuiteId - The ID of the test suite
- * @param testSuiteName - The name of the test suite
- * @param testSuiteDescription - The description of the test suite
- * @param moduleName - The name of the module the test suite belongs to
- * @returns Promise<string> - The path to the generated feature file
- */
 export async function generateFeatureFile(
   testSuiteId: string,
   testSuiteName: string,
   testSuiteDescription?: string,
 ): Promise<string> {
   try {
-    // Fetch test suite with test cases, steps, tags, and all modules for path building
+    await ensureAutomationWorkspaceReady()
     const [testSuite, allModules] = await Promise.all([
       prisma.testSuite.findUnique({
         where: { id: testSuiteId },
@@ -85,35 +58,28 @@ export async function generateFeatureFile(
           tags: true,
         },
       }),
-      prisma.module.findMany(), // Get all modules to build hierarchy path
+      prisma.module.findMany(),
     ])
 
     if (!testSuite) {
       throw new Error(`Test suite with ID ${testSuiteId} not found`)
     }
 
-    // Build the module path for directory structure
     const modulePath = buildModulePath(allModules, testSuite.module)
-
-    // Generate feature file content
     const featureContent = generateFeatureContent(
-      testSuiteDescription || testSuiteName, // Use description as feature title, fallback to name
+      testSuiteDescription || testSuiteName,
       testSuite.testCases,
       testSuite.tags,
     )
 
-    // Create the features directory with module path
-    const featuresBaseDir = join(process.cwd(), 'src', 'tests', 'features')
-    const moduleDir = join(featuresBaseDir, modulePath.substring(1)) // Remove leading slash
+    const featuresBaseDir = getAutomationFeaturesDir()
+    const moduleDir = join(featuresBaseDir, modulePath.substring(1))
     await fs.mkdir(moduleDir, { recursive: true })
 
-    // Generate a safe filename from the test suite name only
     const safeFileName = generateSafeFileName(testSuiteName)
     const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
-    // Write the feature file
     await fs.writeFile(featureFilePath, featureContent, 'utf8')
-
     return featureFilePath
   } catch (error) {
     console.error('Error generating feature file:', error)
@@ -121,9 +87,6 @@ export async function generateFeatureFile(
   }
 }
 
-/**
- * Generates the content for a Gherkin feature file
- */
 function generateFeatureContent(
   featureTitle: string,
   testCases: Array<{
@@ -143,45 +106,35 @@ function generateFeatureContent(
 ): string {
   const lines: string[] = []
 
-  // Warning header
   lines.push('# AUTO-GENERATED FILE - DO NOT EDIT MANUALLY')
   lines.push('# This file is automatically generated from Test Suite data.')
   lines.push('# Any manual changes will be overwritten when the Test Suite is updated.')
   lines.push('# To modify this feature, update the corresponding Test Suite in the application.')
   lines.push('')
 
-  // Add feature-level tags (one tag per line)
   if (testSuiteTags && testSuiteTags.length > 0) {
     testSuiteTags.forEach(tag => {
       lines.push(tag.tagExpression)
     })
   }
 
-  // Feature header - use description as feature title
   lines.push(`Feature: ${featureTitle}`)
   lines.push('')
 
-  // Get test suite tag expressions for deduplication
   const testSuiteTagExpressions = new Set((testSuiteTags || []).map(tag => tag.tagExpression.toLowerCase()))
-
-  // Generate scenarios for each test case that has steps
   let scenarioCount = 0
+
   testCases.forEach(testCase => {
-    // Only generate scenario if test case has steps
     if (testCase.steps && testCase.steps.length > 0) {
-      // Generate Gherkin steps from test case steps
       const gherkinSteps = generateGherkinStepsFromTestCase(testCase.steps)
 
-      // Only add scenario if there are actual gherkin steps
       if (gherkinSteps.length > 0) {
         if (scenarioCount > 0) {
-          lines.push('') // Add blank line between scenarios
+          lines.push('')
         }
 
-        // Add scenario-level tags (skip if already present at feature level)
         if (testCase.tags && testCase.tags.length > 0) {
           testCase.tags.forEach(tag => {
-            // Only add tag if it's not already present at feature level
             if (!testSuiteTagExpressions.has(tag.tagExpression.toLowerCase())) {
               lines.push(`  ${tag.tagExpression}`)
             }
@@ -189,11 +142,9 @@ function generateFeatureContent(
         }
 
         lines.push(`  Scenario: [${testCase.title}] ${testCase.description}`)
-
         gherkinSteps.forEach(step => {
           lines.push(`    ${step}`)
         })
-
         scenarioCount++
       }
     }
@@ -202,9 +153,6 @@ function generateFeatureContent(
   return lines.join('\n') + '\n'
 }
 
-/**
- * Generates Gherkin steps from test case steps using the same logic as the frontend
- */
 function generateGherkinStepsFromTestCase(
   steps: Array<{
     gherkinStep: string
@@ -215,9 +163,7 @@ function generateGherkinStepsFromTestCase(
     return []
   }
 
-  // Sort steps by order
   const sortedSteps = steps.sort((a, b) => a.order - b.order)
-
   let hasThenInPrevious = false
   let hasWhenInPrevious = false
 
@@ -227,55 +173,43 @@ function generateGherkinStepsFromTestCase(
     const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
     const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
 
-    // First step always starts with Given
     if (index === 0) {
       return `Given ${stepWithoutKeyword}`
     }
 
-    // Check if this step should be a Then statement
     const isThenStatement =
       firstWord === 'then' ||
       stepWithoutKeyword.toLowerCase().startsWith('should') ||
       stepWithoutKeyword.toLowerCase().startsWith('must') ||
       stepWithoutKeyword.toLowerCase().startsWith('will')
 
-    // If we haven't seen a Then yet
     if (!hasThenInPrevious) {
-      // If this is a Then statement
       if (isThenStatement) {
         hasThenInPrevious = true
         return `Then ${stepWithoutKeyword}`
       }
 
-      // If we haven't seen a When yet, use When
       if (!hasWhenInPrevious) {
         hasWhenInPrevious = true
         return `When ${stepWithoutKeyword}`
       }
-      // After When, use And
+
       return `And ${stepWithoutKeyword}`
     }
 
-    // After Then
     if (isThenStatement) {
-      // If it's another Then statement, use And
       return `And ${stepWithoutKeyword}`
     }
-    // After Then, use When for new actions
+
     hasThenInPrevious = false
     hasWhenInPrevious = true
     return `When ${stepWithoutKeyword}`
   })
 }
 
-/**
- * Deletes a feature file for a test suite
- * @param testSuiteId - The ID of the test suite
- * @returns Promise<boolean> - True if file was deleted, false if file didn't exist
- */
 export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
   try {
-    // Fetch test suite and all modules to build the correct path
+    await ensureAutomationWorkspaceReady()
     const [testSuite, allModules] = await Promise.all([
       prisma.testSuite.findUnique({
         where: { id: testSuiteId },
@@ -287,29 +221,22 @@ export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
     ])
 
     if (!testSuite) {
-      console.warn(`Test suite with ID ${testSuiteId} not found for feature file deletion`)
       return false
     }
 
-    // Build the module path for directory structure
     const modulePath = buildModulePath(allModules, testSuite.module)
     const safeFileName = generateSafeFileName(testSuite.name)
 
-    const featuresBaseDir = join(process.cwd(), 'src', 'tests', 'features')
-    const moduleDir = join(featuresBaseDir, modulePath.substring(1)) // Remove leading slash
+    const featuresBaseDir = getAutomationFeaturesDir()
+    const moduleDir = join(featuresBaseDir, modulePath.substring(1))
     const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
     try {
       await fs.unlink(featureFilePath)
-      console.log(`Feature file deleted: ${featureFilePath}`)
-
-      // Clean up empty directories up the module hierarchy
       await removeEmptyDirectoriesUp(moduleDir, featuresBaseDir)
-
       return true
     } catch (error: unknown) {
       if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-        console.warn(`Feature file not found for deletion: ${featureFilePath}`)
         return false
       }
       throw error
@@ -320,24 +247,19 @@ export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
   }
 }
 
-/**
- * Regenerates all feature files from the current database state
- * This is useful after merging changes or database migrations to ensure sync
- * @returns Promise<string[]> - Array of generated feature file paths
- */
 export async function regenerateAllFeatureFiles(): Promise<string[]> {
   try {
-    console.log('Starting regeneration of all feature files...')
+    await ensureAutomationWorkspaceReady()
+    const featuresBaseDir = getAutomationFeaturesDir()
 
-    // Clear existing feature files directory
-    const featuresBaseDir = join(process.cwd(), 'src', 'tests', 'features')
     try {
       await fs.rm(featuresBaseDir, { recursive: true, force: true })
     } catch (error) {
       console.warn('Could not clear features directory:', error)
     }
 
-    // Fetch all test suites from database
+    await fs.mkdir(featuresBaseDir, { recursive: true })
+
     const testSuites = await prisma.testSuite.findMany({
       include: {
         testCases: {
@@ -358,12 +280,9 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
       },
     })
 
-    // Fetch all modules for path building
     const allModules = await prisma.module.findMany()
-
     const generatedFiles: string[] = []
 
-    // Generate feature file for each test suite
     for (const testSuite of testSuites) {
       try {
         const modulePath = buildModulePath(allModules, testSuite.module)
@@ -373,24 +292,19 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
           testSuite.tags,
         )
 
-        // Create the features directory with module path
-        const moduleDir = join(featuresBaseDir, modulePath.substring(1)) // Remove leading slash
+        const moduleDir = join(featuresBaseDir, modulePath.substring(1))
         await fs.mkdir(moduleDir, { recursive: true })
 
-        // Generate filename and write file
         const safeFileName = generateSafeFileName(testSuite.name)
         const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
         await fs.writeFile(featureFilePath, featureContent, 'utf8')
         generatedFiles.push(featureFilePath)
-
-        console.log(`Generated: ${featureFilePath}`)
       } catch (error) {
         console.error(`Error generating feature file for test suite ${testSuite.name}:`, error)
       }
     }
 
-    console.log(`Regeneration complete. Generated ${generatedFiles.length} feature files.`)
     return generatedFiles
   } catch (error) {
     console.error('Error during feature files regeneration:', error)
@@ -398,14 +312,10 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
   }
 }
 
-/**
- * Generates a safe filename from test suite name
- */
 function generateSafeFileName(testSuiteName: string): string {
-  // Convert to lowercase and replace spaces and special characters with hyphens
   return testSuiteName
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
-    .replace(/-+/g, '-') // Replace multiple consecutive hyphens with single hyphen
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-')
 }