create-appraise 0.1.0

package/templates/default/src/lib/test-run/report-parser.ts

@@ -0,0 +1,316 @@
+import { readFile } from 'fs/promises'
+import { StepStatus, StepKeyword } from '@prisma/client'
+
+/**
+ * Parsed report structure matching cucumber.json format
+ */
+export interface ParsedReport {
+  features: Array<{
+    name: string
+    description: string
+    uri: string
+    line: number
+    keyword: string
+    tags: Array<{ name: string; line: number }>
+    scenarios: Array<{
+      name: string
+      description: string
+      line: number
+      keyword: string
+      type: string
+      cucumberId: string
+      tags: Array<{ name: string; line: number }>
+      steps: Array<{
+        keyword: string
+        line: number | null
+        name: string
+        matchLocation?: string
+        status: string
+        duration: number
+        errorMessage?: string
+        errorTrace?: string
+        hidden: boolean
+        order: number
+      }>
+      hooks: Array<{
+        keyword: string
+        status: string
+        duration: number
+        errorMessage?: string
+        errorTrace?: string
+        hidden: boolean
+      }>
+    }>
+  }>
+}
+
+/**
+ * Cucumber JSON report structure (as received from cucumber-js)
+ */
+interface CucumberJsonFeature {
+  description: string
+  elements: Array<{
+    description: string
+    id: string
+    keyword: string
+    line: number
+    name: string
+    steps: Array<{
+      keyword: string
+      line?: number
+      name?: string
+      hidden?: boolean
+      match?: {
+        location: string
+      }
+      result?: {
+        status: string
+        duration?: number
+        error_message?: string
+      }
+    }>
+    tags: Array<{
+      name: string
+      line: number
+    }>
+    type: string
+  }>
+  id: string
+  line: number
+  keyword: string
+  name: string
+  tags: Array<{
+    name: string
+    line: number
+  }>
+  uri: string
+}
+
+/**
+ * Maps cucumber step status to Prisma StepStatus enum
+ */
+function mapStepStatus(status: string): StepStatus {
+  const upperStatus = status.toUpperCase()
+  switch (upperStatus) {
+    case 'PASSED':
+      return StepStatus.PASSED
+    case 'FAILED':
+      return StepStatus.FAILED
+    case 'SKIPPED':
+      return StepStatus.SKIPPED
+    case 'PENDING':
+      return StepStatus.PENDING
+    case 'UNDEFINED':
+      return StepStatus.UNDEFINED
+    default:
+      return StepStatus.PENDING
+  }
+}
+
+/**
+ * Maps cucumber step keyword to Prisma StepKeyword enum
+ */
+function mapStepKeyword(keyword: string): StepKeyword {
+  const trimmedKeyword = keyword.trim()
+  const upperKeyword = trimmedKeyword.toUpperCase()
+  switch (upperKeyword) {
+    case 'GIVEN':
+      return StepKeyword.GIVEN
+    case 'WHEN':
+      return StepKeyword.WHEN
+    case 'THEN':
+      return StepKeyword.THEN
+    case 'AND':
+      return StepKeyword.AND
+    case 'BUT':
+      return StepKeyword.BUT
+    case 'BEFORE':
+      return StepKeyword.BEFORE
+    case 'AFTER':
+      return StepKeyword.AFTER
+    default:
+      // Default to GIVEN for unknown keywords
+      return StepKeyword.GIVEN
+  }
+}
+
+/**
+ * Separates error message from stack trace
+ * Cucumber's error_message typically contains both the error message and stack trace
+ * The stack trace usually starts with "at" or contains file paths
+ *
+ * @param errorMessage - The full error message from Cucumber
+ * @returns Object with separated message and trace
+ */
+function separateErrorMessageAndTrace(errorMessage: string | undefined): {
+  message: string | undefined
+  trace: string | undefined
+} {
+  if (!errorMessage) {
+    return { message: undefined, trace: undefined }
+  }
+
+  // Look for common stack trace indicators
+  // Stack traces typically start with "at", "    at", or contain file paths with line numbers
+  const stackTracePatterns = [
+    /\n\s*at\s/, // "at" at the start of a line (with optional whitespace)
+    /\n\s+at\s/, // "at" with leading whitespace
+    /Error:\s*$/m, // Error: at end of line (message ends, trace starts)
+  ]
+
+  // Find the first occurrence of a stack trace pattern
+  let splitIndex = -1
+  for (const pattern of stackTracePatterns) {
+    const match = errorMessage.match(pattern)
+    if (match && match.index !== undefined) {
+      // If we find "at" pattern, split before it (include the newline before "at")
+      // If we find "Error:" pattern, split after it
+      if (pattern.source.includes('Error:')) {
+        splitIndex = match.index + match[0].length
+      } else {
+        splitIndex = match.index
+      }
+      break
+    }
+  }
+
+  // If no stack trace pattern found, check if it looks like just a message (short, no file paths)
+  if (splitIndex === -1) {
+    // Check if it contains file paths (common in stack traces)
+    const hasFilePath = /[\/\\][\w\-\.]+:\d+/.test(errorMessage)
+    if (hasFilePath && errorMessage.length > 200) {
+      // Likely contains a trace, try to find where message ends
+      // Usually the first few lines are the message, rest is trace
+      const lines = errorMessage.split('\n')
+      // Look for the first line that starts with whitespace and "at" or contains a file path
+      for (let i = 0; i < lines.length; i++) {
+        if (/^\s*at\s/.test(lines[i]) || /[\/\\][\w\-\.]+:\d+/.test(lines[i])) {
+          splitIndex = errorMessage.indexOf(lines[i])
+          break
+        }
+      }
+    }
+  }
+
+  if (splitIndex > 0) {
+    const message = errorMessage.substring(0, splitIndex).trim()
+    const trace = errorMessage.substring(splitIndex).trim()
+    return {
+      message: message || undefined,
+      trace: trace || undefined,
+    }
+  }
+
+  // If we can't separate them, treat the whole thing as the message
+  // and leave trace as undefined (better than duplicating)
+  return {
+    message: errorMessage.trim() || undefined,
+    trace: undefined,
+  }
+}
+
+/**
+ * Parses a cucumber.json report file into a structured ParsedReport object
+ *
+ * @param reportPath - Path to the cucumber.json file
+ * @returns Parsed report structure
+ * @throws Error if file cannot be read or parsed
+ */
+export async function parseCucumberReport(reportPath: string): Promise<ParsedReport> {
+  try {
+    // Read the report file
+    const fileContent = await readFile(reportPath, 'utf-8')
+    const cucumberData: CucumberJsonFeature[] = JSON.parse(fileContent)
+
+    // Parse features
+    const features = cucumberData.map(feature => {
+      // Separate steps into regular steps and hooks
+      const scenarios = feature.elements.map(element => {
+        const steps: ParsedReport['features'][0]['scenarios'][0]['steps'] = []
+        const hooks: ParsedReport['features'][0]['scenarios'][0]['hooks'] = []
+
+        element.steps.forEach((step, index) => {
+          const isHook = step.keyword === 'Before' || step.keyword === 'After'
+          const stepStatus = step.result?.status || 'pending'
+          const duration = step.result?.duration || 0
+
+          // Separate error message from stack trace
+          const { message: errorMessage, trace: errorTrace } = separateErrorMessageAndTrace(step.result?.error_message)
+
+          if (isHook) {
+            hooks.push({
+              keyword: step.keyword,
+              status: stepStatus,
+              duration,
+              errorMessage,
+              errorTrace,
+              hidden: step.hidden || false,
+            })
+          } else {
+            steps.push({
+              keyword: step.keyword.trim(),
+              line: step.line || null,
+              name: step.name || '',
+              matchLocation: step.match?.location,
+              status: stepStatus,
+              duration,
+              errorMessage,
+              errorTrace,
+              hidden: step.hidden || false,
+              order: index,
+            })
+          }
+        })
+
+        return {
+          name: element.name,
+          description: element.description || '',
+          line: element.line,
+          keyword: element.keyword,
+          type: element.type,
+          cucumberId: element.id,
+          tags: element.tags.map(tag => ({
+            name: tag.name,
+            line: tag.line,
+          })),
+          steps,
+          hooks,
+        }
+      })
+
+      return {
+        name: feature.name,
+        description: feature.description || '',
+        uri: feature.uri,
+        line: feature.line,
+        keyword: feature.keyword,
+        tags: feature.tags.map(tag => ({
+          name: tag.name,
+          line: tag.line,
+        })),
+        scenarios,
+      }
+    })
+
+    return { features }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse cucumber report at ${reportPath}: ${error.message}`)
+    }
+    throw new Error(`Failed to parse cucumber report at ${reportPath}: Unknown error`)
+  }
+}
+
+/**
+ * Helper function to convert parsed step status to Prisma enum
+ */
+export function getStepStatusEnum(status: string): StepStatus {
+  return mapStepStatus(status)
+}
+
+/**
+ * Helper function to convert parsed step keyword to Prisma enum
+ */
+export function getStepKeywordEnum(keyword: string): StepKeyword {
+  return mapStepKeyword(keyword)
+}

package/templates/default/src/lib/test-run/test-run-executor.ts

@@ -0,0 +1,144 @@
+import { BrowserEngine, Environment, Tag } from '@prisma/client'
+import { spawnTask } from '@/tests/utils/spawner.util'
+import { processManager } from './process-manager'
+import type { SpawnedProcess } from '@/tests/utils/spawner.util'
+import { join } from 'path'
+
+/**
+ * Configuration for executing a test run
+ */
+export interface TestRunExecutionConfig {
+  testRunId: string
+  environment: Environment
+  tags: Tag[]
+  testWorkersCount: number
+  browserEngine: BrowserEngine
+  headless?: boolean
+}
+
+/**
+ * Maps BrowserEngine enum to browser name string for CLI
+ */
+function mapBrowserEngineToName(browserEngine: BrowserEngine): 'chromium' | 'firefox' | 'webkit' {
+  switch (browserEngine) {
+    case BrowserEngine.CHROMIUM:
+      return 'chromium'
+    case BrowserEngine.FIREFOX:
+      return 'firefox'
+    case BrowserEngine.WEBKIT:
+      return 'webkit'
+    default:
+      return 'chromium'
+  }
+}
+
+/**
+ * Combines multiple tag expressions into a single Cucumber tag expression
+ * Uses OR logic to combine tags: (@tag1 or @tag2 or @tag3)
+ */
+function combineTagExpressions(tags: Tag[]): string | null {
+  if (tags.length === 0) {
+    return null
+  }
+
+  if (tags.length === 1) {
+    return tags[0].tagExpression
+  }
+
+  // Combine multiple tag expressions with OR
+  return tags.map(tag => `(${tag.tagExpression})`).join(' or ')
+}
+
+/**
+ * Generates a unique report path for a test run
+ * Format: src/tests/reports/cucumber-{testRunId}-{timestamp}.json
+ *
+ * @param testRunId - The test run ID (runId, not id)
+ * @returns The full path to the report file
+ */
+export function generateReportPath(testRunId: string): string {
+  const timestamp = Date.now()
+  const reportFileName = `cucumber-${testRunId}-${timestamp}.json`
+  const reportPath = join(process.cwd(), 'src', 'tests', 'reports', reportFileName)
+  return reportPath
+}
+
+/**
+ * Sets environment variables for the test execution
+ */
+function setEnvironmentVariables(
+  environment: Environment,
+  headless: boolean,
+  browser: string,
+  reportPath?: string,
+): void {
+  process.env.ENVIRONMENT = environment.name
+  process.env.HEADLESS = headless.toString()
+  process.env.BROWSER = browser
+  if (reportPath) {
+    process.env.REPORT_PATH = reportPath
+  }
+}
+
+/**
+ * Executes a test run by spawning a cucumber process
+ *
+ * @param config - Test run execution configuration
+ * @returns Promise that resolves to an object containing the spawned process and report path
+ */
+export async function executeTestRun(config: TestRunExecutionConfig): Promise<{
+  process: SpawnedProcess
+  reportPath: string
+}> {
+  const { testRunId, environment, tags, testWorkersCount, browserEngine, headless = true } = config
+
+  // Generate unique report path
+  const reportPath = generateReportPath(testRunId)
+
+  // Map browser engine to browser name
+  const browserName = mapBrowserEngineToName(browserEngine)
+
+  // Set environment variables including report path
+  setEnvironmentVariables(environment, headless, browserName, reportPath)
+
+  // Build cucumber command arguments
+  const cucumberArgs: string[] = []
+
+  // Add tag expression if tags are provided
+  const tagExpression = combineTagExpressions(tags)
+  if (tagExpression) {
+    cucumberArgs.push('-t', tagExpression)
+  }
+
+  // Add parallel flag if workers > 1
+  if (testWorkersCount > 1) {
+    cucumberArgs.push('--parallel', testWorkersCount.toString())
+  }
+
+  // Spawn the cucumber test process
+  // Enable streamLogs to see output in console for debugging
+  // Use captureOutput: true to capture logs for streaming
+  const process = await spawnTask('npx', ['cucumber-js', ...cucumberArgs], {
+    streamLogs: true, // Enable console output to verify logs are being generated
+    prefixLogs: true, // Add prefix to identify logs
+    logPrefix: `test-run-${testRunId}`,
+    captureOutput: true, // Capture output for streaming
+  })
+
+  // Register the process in ProcessManager
+  console.log(`[TestRunExecutor] Registering process for testRunId: ${testRunId}, process name: ${process.name}`)
+  processManager.register(testRunId, process)
+  console.log(`[TestRunExecutor] Process registered. ProcessManager now has ${processManager.size()} processes`)
+
+  // Set up exit handler - Immediately unregister process to free up memory
+  process.process.on('exit', code => {
+    // Immediately unregister the process to free up memory
+    // Log storage will be handled in createTestRunAction after process completion
+    processManager.unregister(testRunId)
+    console.log(
+      `[TestRunExecutor] Process exited for testRunId: ${testRunId} with code ${code}, unregistered from ProcessManager`,
+    )
+  })
+
+  return { process, reportPath }
+}

package/templates/default/src/lib/test-run/winston-logger.ts

@@ -0,0 +1,95 @@
+import winston from 'winston'
+import path from 'path'
+import { promises as fs } from 'fs'
+
+const LOGS_DIR = path.join(process.cwd(), 'src', 'tests', 'reports', 'logs')
+
+/**
+ * Ensures the logs directory exists, creating it if necessary
+ */
+async function ensureLogsDirectory(): Promise<void> {
+  try {
+    await fs.access(LOGS_DIR)
+  } catch {
+    // Directory doesn't exist, create it
+    await fs.mkdir(LOGS_DIR, { recursive: true })
+  }
+}
+
+/**
+ * Creates a Winston logger instance for a specific test run
+ * @param testRunId - The unique test run ID (runId, not id)
+ * @returns A configured Winston logger instance
+ */
+export async function createTestRunLogger(testRunId: string): Promise<winston.Logger> {
+  // Ensure logs directory exists
+  await ensureLogsDirectory()
+
+  // Create log file path
+  const logFilePath = path.join(LOGS_DIR, `${testRunId}.log`)
+
+  // Define log format
+  const logFormat = winston.format.combine(
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    winston.format.errors({ stack: true }),
+    winston.format.printf(({ timestamp, level, message, stack }) => {
+      if (stack) {
+        return `${timestamp} [${level.toUpperCase()}]: ${message}\n${stack}`
+      }
+      return `${timestamp} [${level.toUpperCase()}]: ${message}`
+    }),
+  )
+
+  // Create logger with console and file transports
+  const logger = winston.createLogger({
+    level: 'info',
+    format: logFormat,
+    transports: [
+      // Console transport (stdout)
+      new winston.transports.Console({
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.printf(({ timestamp, level, message, stack }) => {
+            if (stack) {
+              return `${timestamp} [${level}]: ${message}\n${stack}`
+            }
+            return `${timestamp} [${level}]: ${message}`
+          }),
+        ),
+      }),
+      // File transport
+      new winston.transports.File({
+        filename: logFilePath,
+        maxsize: 10 * 1024 * 1024, // 10MB
+        maxFiles: 5,
+      }),
+    ],
+  })
+
+  return logger
+}
+
+/**
+ * Closes a Winston logger instance, ensuring all logs are flushed
+ * @param logger - The logger instance to close
+ */
+export async function closeLogger(logger: winston.Logger): Promise<void> {
+  return new Promise((resolve, reject) => {
+    logger.end((err: Error | null) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+/**
+ * Gets the log file path for a test run
+ * @param testRunId - The unique test run ID (runId, not id)
+ * @returns The absolute path to the log file
+ */
+export function getLogFilePath(testRunId: string): string {
+  return path.join(LOGS_DIR, `${testRunId}.log`)
+}

package/templates/default/src/lib/transformers/gherkin-converter.ts

@@ -0,0 +1,42 @@
+import { TemplateStepType } from '@prisma/client'
+
+export const generateGherkinStep = (
+  type: TemplateStepType,
+  signature: string,
+  parameters: { value: string; order: number }[],
+) => {
+  const signatureParts = signature.split(' ')
+  const sortedParameters = parameters.sort((a, b) => a.order - b.order)
+
+  const gherkinStep = signatureParts
+    .map(part => {
+      // Check if this part is a parameter placeholder
+      if (part.startsWith('{') && part.endsWith('}')) {
+        const parameter = sortedParameters.shift()
+
+        // If no parameter or missing value, return the placeholder to indicate incompleteness
+        if (!parameter || !parameter.value || parameter.value.trim() === '') {
+          return part
+        }
+
+        // Format the parameter value based on its type
+        switch (part) {
+          case '{string}':
+            return `"${parameter.value}"`
+          case '{int}':
+            return parameter.value
+          case '{boolean}':
+            return parameter.value
+          default:
+            return parameter.value
+        }
+      }
+
+      return part
+    })
+    .join(' ')
+
+  // Prepend the appropriate Gherkin keyword based on type
+  const keyword = type === 'ACTION' ? 'When' : 'Then'
+  return `${keyword} ${gherkinStep}`
+}

package/templates/default/src/lib/transformers/key-to-icon-transformer.tsx

@@ -0,0 +1,95 @@
+import { TemplateStepIcon } from '@prisma/client'
+import {
+  ALargeSmall,
+  BugPlay,
+  Database,
+  Download,
+  Globe,
+  Keyboard,
+  MousePointerClick,
+  Save,
+  Server,
+  Upload,
+  Loader,
+  CheckCheck,
+  LucideIcon,
+} from 'lucide-react'
+import { ReactElement } from 'react'
+
+export const KeyToIconTransformer = (key: TemplateStepIcon, className?: string) => {
+  switch (key) {
+    case 'MOUSE':
+      return <MousePointerClick className={className} />
+    case 'NAVIGATION':
+      return <Globe className={className} />
+    case 'INPUT':
+      return <Keyboard className={className} />
+    case 'DOWNLOAD':
+      return <Download className={className} />
+    case 'API':
+      return <Server className={className} />
+    case 'STORE':
+      return <Save className={className} />
+    case 'FORMAT':
+      return <ALargeSmall className={className} />
+    case 'DATA':
+      return <Database className={className} />
+    case 'UPLOAD':
+      return <Upload className={className} />
+    case 'WAIT':
+      return <Loader className={className} />
+    case 'VALIDATION':
+      return <CheckCheck className={className} />
+    case 'DEBUG':
+      return <BugPlay className={className} />
+  }
+}
+
+// Map of component types to TemplateStepIcon values
+const componentToIconMap = new Map<LucideIcon, TemplateStepIcon>([
+  [MousePointerClick, 'MOUSE'],
+  [Globe, 'NAVIGATION'],
+  [Keyboard, 'INPUT'],
+  [Download, 'DOWNLOAD'],
+  [Server, 'API'],
+  [Save, 'STORE'],
+  [ALargeSmall, 'FORMAT'],
+  [Database, 'DATA'],
+  [Upload, 'UPLOAD'],
+  [Loader, 'WAIT'],
+  [CheckCheck, 'VALIDATION'],
+  [BugPlay, 'DEBUG'],
+])
+
+// Map of string values to TemplateStepIcon values
+const stringToIconMap = new Map<string, TemplateStepIcon>([
+  ['MOUSE', 'MOUSE'],
+  ['NAVIGATION', 'NAVIGATION'],
+  ['INPUT', 'INPUT'],
+  ['DOWNLOAD', 'DOWNLOAD'],
+  ['API', 'API'],
+  ['STORE', 'STORE'],
+  ['FORMAT', 'FORMAT'],
+  ['DATA', 'DATA'],
+  ['UPLOAD', 'UPLOAD'],
+  ['WAIT', 'WAIT'],
+  ['VALIDATION', 'VALIDATION'],
+  ['DEBUG', 'DEBUG'],
+])
+
+export const IconToKeyTransformer = (icon: React.ReactNode | string): TemplateStepIcon | undefined => {
+  // Handle string input
+  if (typeof icon === 'string') {
+    return stringToIconMap.get(icon)
+  }
+
+  // Handle React component input
+  if (!icon || typeof icon !== 'object') return undefined
+
+  // Get the component type from the React element
+  const componentType = (icon as ReactElement)?.type
+  if (!componentType) return undefined
+
+  // Look up the icon in our map
+  return componentToIconMap.get(componentType as LucideIcon)
+}