create-appraisejs 0.1.6 → 0.1.8-alpha

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

@@ -1,144 +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 }
-}
+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

@@ -1,95 +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`)
-}
+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

@@ -1,42 +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}`
-}
+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}`
+}