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

package/templates/default/src/lib/database-sync.ts

@@ -3,6 +3,7 @@ import prisma from '@/config/db-config'
 import { ParsedFeature, ParsedStep } from './gherkin-parser'
 import { buildModuleHierarchy } from './module-hierarchy-builder'
 import { TemplateStepType, TemplateStepIcon, TestCase, TagType } from '@prisma/client'
+import { getTagTypeFromExpression } from './tag-utils'
 
 /**
  * Syncs feature files to the database by creating missing test suites and test cases
@@ -93,13 +94,7 @@ export async function syncFeaturesToDatabase(
  * @returns TagType - IDENTIFIER if matches pattern, FILTER otherwise
  */
 function determineTagType(tagExpression: string): TagType {
-  // Pattern: @xx_id_xxxxxxxx where:
-  // - @ = literal @
-  // - xx = any 2 characters
-  // - _id_ = literal string
-  // - xxxxxxxx = any characters
-  const identifierPattern = /^@.{2}_id_.+$/
-  return identifierPattern.test(tagExpression) ? TagType.IDENTIFIER : TagType.FILTER
+  return getTagTypeFromExpression(tagExpression)
 }
 
 /**

package/templates/default/src/lib/environment-file-utils.ts

@@ -1,184 +1,184 @@
-import { promises as fs } from 'fs'
-import * as path from 'path'
-import prisma from '@/config/db-config'
-import { ensureAutomationWorkspaceReady, getAutomationEnvironmentsDir } from '@/lib/automation/paths'
-
-interface EnvironmentConfig {
-  baseUrl: string
-  apiBaseUrl: string
-  email: string
-  password: string
-}
-
-export function getEnvironmentsFilePath(): string {
-  return path.join(getAutomationEnvironmentsDir(), 'environments.json')
-}
-
-export async function ensureConfigDirectoryExists(): Promise<void> {
-  await ensureAutomationWorkspaceReady()
-  await fs.mkdir(path.dirname(getEnvironmentsFilePath()), { recursive: true })
-}
-
-export async function generateEnvironmentsContent(): Promise<Record<string, EnvironmentConfig>> {
-  try {
-    const environments = await prisma.environment.findMany({
-      orderBy: { createdAt: 'asc' },
-    })
-
-    const environmentsConfig: Record<string, EnvironmentConfig> = {}
-
-    environments.forEach(env => {
-      const envKey = env.name.toLowerCase().replace(/\s+/g, '_')
-      environmentsConfig[envKey] = {
-        baseUrl: env.baseUrl,
-        apiBaseUrl: env.apiBaseUrl || '',
-        email: env.username || '',
-        password: env.password || '',
-      }
-    })
-
-    return environmentsConfig
-  } catch (error) {
-    console.error('Error generating environments content:', error)
-    return {}
-  }
-}
-
-export async function createOrUpdateEnvironmentsFile(): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-    await ensureConfigDirectoryExists()
-
-    const content = await generateEnvironmentsContent()
-
-    if (Object.keys(content).length === 0) {
-      await deleteEnvironmentsFile()
-      return true
-    }
-
-    await fs.writeFile(filePath, JSON.stringify(content, null, 2))
-    return true
-  } catch (error) {
-    console.error('Error creating/updating environments file:', error)
-    return false
-  }
-}
-
-export async function deleteEnvironmentsFile(): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-
-    try {
-      await fs.access(filePath)
-    } catch {
-      return true
-    }
-
-    await fs.unlink(filePath)
-    return true
-  } catch (error) {
-    console.error('Error deleting environments file:', error)
-    return false
-  }
-}
-
-export async function readEnvironmentsFile(): Promise<{
-  filePath: string
-  content: Record<string, EnvironmentConfig>
-} | null> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-
-    try {
-      await fs.access(filePath)
-    } catch {
-      return null
-    }
-
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    const jsonContent = JSON.parse(fileContent)
-
-    return { filePath, content: jsonContent }
-  } catch (error) {
-    console.error('Error reading environments file:', error)
-    return null
-  }
-}
-
-export async function updateEnvironmentEntry(environmentId: string, oldName?: string): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const environment = await prisma.environment.findUnique({
-      where: { id: environmentId },
-    })
-
-    if (!environment) {
-      console.error(`Environment with ID ${environmentId} not found`)
-      return false
-    }
-
-    const filePath = getEnvironmentsFilePath()
-    let environmentsConfig: Record<string, EnvironmentConfig> = {}
-
-    try {
-      await fs.access(filePath)
-      const fileContent = await fs.readFile(filePath, 'utf-8')
-      environmentsConfig = JSON.parse(fileContent)
-    } catch {
-      environmentsConfig = {}
-    }
-
-    if (oldName) {
-      const oldKey = oldName.toLowerCase().replace(/\s+/g, '_')
-      delete environmentsConfig[oldKey]
-    }
-
-    const envKey = environment.name.toLowerCase().replace(/\s+/g, '_')
-    environmentsConfig[envKey] = {
-      baseUrl: environment.baseUrl,
-      apiBaseUrl: environment.apiBaseUrl || '',
-      email: environment.username || '',
-      password: environment.password || '',
-    }
-
-    await ensureConfigDirectoryExists()
-    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
-    return true
-  } catch (error) {
-    console.error('Error updating environment entry:', error)
-    return false
-  }
-}
-
-export async function removeEnvironmentEntry(environmentName: string): Promise<boolean> {
-  try {
-    await ensureAutomationWorkspaceReady()
-    const filePath = getEnvironmentsFilePath()
-
-    try {
-      await fs.access(filePath)
-    } catch {
-      return true
-    }
-
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    const environmentsConfig: Record<string, EnvironmentConfig> = JSON.parse(fileContent)
-
-    const envKey = environmentName.toLowerCase().replace(/\s+/g, '_')
-    delete environmentsConfig[envKey]
-
-    if (Object.keys(environmentsConfig).length === 0) {
-      await deleteEnvironmentsFile()
-      return true
-    }
-
-    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
-    return true
-  } catch (error) {
-    console.error('Error removing environment entry:', error)
-    return false
-  }
-}
+import { promises as fs } from 'fs'
+import * as path from 'path'
+import prisma from '@/config/db-config'
+import { ensureAutomationWorkspaceReady, getAutomationEnvironmentsDir } from '@/lib/automation/paths'
+
+interface EnvironmentConfig {
+  baseUrl: string
+  apiBaseUrl: string
+  email: string
+  password: string
+}
+
+export function getEnvironmentsFilePath(): string {
+  return path.join(getAutomationEnvironmentsDir(), 'environments.json')
+}
+
+export async function ensureConfigDirectoryExists(): Promise<void> {
+  await ensureAutomationWorkspaceReady()
+  await fs.mkdir(path.dirname(getEnvironmentsFilePath()), { recursive: true })
+}
+
+export async function generateEnvironmentsContent(): Promise<Record<string, EnvironmentConfig>> {
+  try {
+    const environments = await prisma.environment.findMany({
+      orderBy: { createdAt: 'asc' },
+    })
+
+    const environmentsConfig: Record<string, EnvironmentConfig> = {}
+
+    environments.forEach(env => {
+      const envKey = env.name.toLowerCase().replace(/\s+/g, '_')
+      environmentsConfig[envKey] = {
+        baseUrl: env.baseUrl,
+        apiBaseUrl: env.apiBaseUrl || '',
+        email: env.username || '',
+        password: env.password || '',
+      }
+    })
+
+    return environmentsConfig
+  } catch (error) {
+    console.error('Error generating environments content:', error)
+    return {}
+  }
+}
+
+export async function createOrUpdateEnvironmentsFile(): Promise<boolean> {
+  try {
+    await ensureAutomationWorkspaceReady()
+    const filePath = getEnvironmentsFilePath()
+    await ensureConfigDirectoryExists()
+
+    const content = await generateEnvironmentsContent()
+
+    if (Object.keys(content).length === 0) {
+      await deleteEnvironmentsFile()
+      return true
+    }
+
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error creating/updating environments file:', error)
+    return false
+  }
+}
+
+export async function deleteEnvironmentsFile(): Promise<boolean> {
+  try {
+    await ensureAutomationWorkspaceReady()
+    const filePath = getEnvironmentsFilePath()
+
+    try {
+      await fs.access(filePath)
+    } catch {
+      return true
+    }
+
+    await fs.unlink(filePath)
+    return true
+  } catch (error) {
+    console.error('Error deleting environments file:', error)
+    return false
+  }
+}
+
+export async function readEnvironmentsFile(): Promise<{
+  filePath: string
+  content: Record<string, EnvironmentConfig>
+} | null> {
+  try {
+    await ensureAutomationWorkspaceReady()
+    const filePath = getEnvironmentsFilePath()
+
+    try {
+      await fs.access(filePath)
+    } catch {
+      return null
+    }
+
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const jsonContent = JSON.parse(fileContent)
+
+    return { filePath, content: jsonContent }
+  } catch (error) {
+    console.error('Error reading environments file:', error)
+    return null
+  }
+}
+
+export async function updateEnvironmentEntry(environmentId: string, oldName?: string): Promise<boolean> {
+  try {
+    await ensureAutomationWorkspaceReady()
+    const environment = await prisma.environment.findUnique({
+      where: { id: environmentId },
+    })
+
+    if (!environment) {
+      console.error(`Environment with ID ${environmentId} not found`)
+      return false
+    }
+
+    const filePath = getEnvironmentsFilePath()
+    let environmentsConfig: Record<string, EnvironmentConfig> = {}
+
+    try {
+      await fs.access(filePath)
+      const fileContent = await fs.readFile(filePath, 'utf-8')
+      environmentsConfig = JSON.parse(fileContent)
+    } catch {
+      environmentsConfig = {}
+    }
+
+    if (oldName) {
+      const oldKey = oldName.toLowerCase().replace(/\s+/g, '_')
+      delete environmentsConfig[oldKey]
+    }
+
+    const envKey = environment.name.toLowerCase().replace(/\s+/g, '_')
+    environmentsConfig[envKey] = {
+      baseUrl: environment.baseUrl,
+      apiBaseUrl: environment.apiBaseUrl || '',
+      email: environment.username || '',
+      password: environment.password || '',
+    }
+
+    await ensureConfigDirectoryExists()
+    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error updating environment entry:', error)
+    return false
+  }
+}
+
+export async function removeEnvironmentEntry(environmentName: string): Promise<boolean> {
+  try {
+    await ensureAutomationWorkspaceReady()
+    const filePath = getEnvironmentsFilePath()
+
+    try {
+      await fs.access(filePath)
+    } catch {
+      return true
+    }
+
+    const fileContent = await fs.readFile(filePath, 'utf-8')
+    const environmentsConfig: Record<string, EnvironmentConfig> = JSON.parse(fileContent)
+
+    const envKey = environmentName.toLowerCase().replace(/\s+/g, '_')
+    delete environmentsConfig[envKey]
+
+    if (Object.keys(environmentsConfig).length === 0) {
+      await deleteEnvironmentsFile()
+      return true
+    }
+
+    await fs.writeFile(filePath, JSON.stringify(environmentsConfig, null, 2))
+    return true
+  } catch (error) {
+    console.error('Error removing environment entry:', error)
+    return false
+  }
+}

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

@@ -1,10 +1,17 @@
-import { join } from 'path'
+import { dirname } from 'path'
 import { spawnTask, taskSpawner, type SpawnedProcess, waitForTask, killTask } from '@/lib/process/task-spawner'
-import { ensureAutomationWorkspaceReady, getAutomationReportsDir } from '@/lib/automation/paths'
+import {
+  ensureAutomationWorkspaceReady,
+  getAutomationRunReportPath,
+  toProjectRelativePath,
+} from '@/lib/automation/paths'
 import type { ExecutorAdapter, TestRunExecutionRequest, TestRunExecutionResult } from './types'
 import { processManager } from '@/lib/test-run/process-manager'
+import { promises as fs } from 'fs'
 
-function mapBrowserEngineToName(browserEngine: TestRunExecutionRequest['browserEngine']): 'chromium' | 'firefox' | 'webkit' {
+function mapBrowserEngineToName(
+  browserEngine: TestRunExecutionRequest['browserEngine'],
+): 'chromium' | 'firefox' | 'webkit' {
   switch (browserEngine) {
     case 'CHROMIUM':
       return 'chromium'
@@ -17,38 +24,29 @@ function mapBrowserEngineToName(browserEngine: TestRunExecutionRequest['browserE
   }
 }
 
-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`)
+  return getAutomationRunReportPath(testRunId)
 }
 
 export class LocalExecutorAdapter implements ExecutorAdapter {
   async executeTestRun(config: TestRunExecutionRequest): Promise<TestRunExecutionResult> {
     await ensureAutomationWorkspaceReady()
 
-    const { testRunId, environment, tags, testWorkersCount, browserEngine, headless = true } = config
+    const { testRunId, environment, tagExpression, 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
+    await fs.mkdir(dirname(reportPath), { recursive: true })
+    const childEnv = {
+      ...process.env,
+      ENVIRONMENT: environment.name,
+      HEADLESS: headless.toString(),
+      BROWSER: browserName,
+      REPORT_PATH: reportPath,
+      REPORT_FORMAT: `json:${reportPath}`,
+      TEST_RUN_ID: testRunId,
+    }
 
     const cucumberArgs: string[] = ['cucumber-js']
-    const tagExpression = combineTagExpressions(tags)
 
     if (tagExpression) {
       cucumberArgs.push('-t', tagExpression)
@@ -63,6 +61,7 @@ export class LocalExecutorAdapter implements ExecutorAdapter {
       prefixLogs: true,
       logPrefix: `test-run-${testRunId}`,
       captureOutput: true,
+      env: childEnv,
     })
 
     processManager.register(testRunId, spawnedProcess)
@@ -72,7 +71,7 @@ export class LocalExecutorAdapter implements ExecutorAdapter {
 
     return {
       process: spawnedProcess,
-      reportPath,
+      reportPath: toProjectRelativePath(reportPath),
     }
   }
 

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

@@ -1,10 +1,10 @@
-import type { BrowserEngine, Environment, Tag } from '@prisma/client'
+import type { BrowserEngine, Environment } from '@prisma/client'
 import type { SpawnedProcess } from '@/lib/process/task-spawner'
 
 export interface TestRunExecutionRequest {
   testRunId: string
   environment: Environment
-  tags: Tag[]
+  tagExpression: string | null
   testWorkersCount: number
   browserEngine: BrowserEngine
   headless?: boolean

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

@@ -3,6 +3,7 @@ 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'
+import { generateProjectedGherkinSteps, getTestSuiteFilesystemKey } from '@/lib/sync/projected-feature-utils'
 
 async function isDirectoryEmpty(dirPath: string): Promise<boolean> {
   try {
@@ -76,7 +77,7 @@ export async function generateFeatureFile(
     const moduleDir = join(featuresBaseDir, modulePath.substring(1))
     await fs.mkdir(moduleDir, { recursive: true })
 
-    const safeFileName = generateSafeFileName(testSuiteName)
+    const safeFileName = getTestSuiteFilesystemKey(testSuiteName)
     const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
     await fs.writeFile(featureFilePath, featureContent, 'utf8')
@@ -126,7 +127,7 @@ function generateFeatureContent(
 
   testCases.forEach(testCase => {
     if (testCase.steps && testCase.steps.length > 0) {
-      const gherkinSteps = generateGherkinStepsFromTestCase(testCase.steps)
+      const gherkinSteps = generateProjectedGherkinSteps(testCase.steps)
 
       if (gherkinSteps.length > 0) {
         if (scenarioCount > 0) {
@@ -153,60 +154,6 @@ function generateFeatureContent(
   return lines.join('\n') + '\n'
 }
 
-function generateGherkinStepsFromTestCase(
-  steps: Array<{
-    gherkinStep: string
-    order: number
-  }>,
-): string[] {
-  if (!steps || steps.length === 0) {
-    return []
-  }
-
-  const sortedSteps = steps.sort((a, b) => a.order - b.order)
-  let hasThenInPrevious = false
-  let hasWhenInPrevious = false
-
-  return sortedSteps.map((step, index) => {
-    const gherkinStep = step.gherkinStep?.trim() || ''
-    const firstWord = gherkinStep.split(' ')[0].toLowerCase()
-    const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
-    const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
-
-    if (index === 0) {
-      return `Given ${stepWithoutKeyword}`
-    }
-
-    const isThenStatement =
-      firstWord === 'then' ||
-      stepWithoutKeyword.toLowerCase().startsWith('should') ||
-      stepWithoutKeyword.toLowerCase().startsWith('must') ||
-      stepWithoutKeyword.toLowerCase().startsWith('will')
-
-    if (!hasThenInPrevious) {
-      if (isThenStatement) {
-        hasThenInPrevious = true
-        return `Then ${stepWithoutKeyword}`
-      }
-
-      if (!hasWhenInPrevious) {
-        hasWhenInPrevious = true
-        return `When ${stepWithoutKeyword}`
-      }
-
-      return `And ${stepWithoutKeyword}`
-    }
-
-    if (isThenStatement) {
-      return `And ${stepWithoutKeyword}`
-    }
-
-    hasThenInPrevious = false
-    hasWhenInPrevious = true
-    return `When ${stepWithoutKeyword}`
-  })
-}
-
 export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
   try {
     await ensureAutomationWorkspaceReady()
@@ -225,7 +172,7 @@ export async function deleteFeatureFile(testSuiteId: string): Promise<boolean> {
     }
 
     const modulePath = buildModulePath(allModules, testSuite.module)
-    const safeFileName = generateSafeFileName(testSuite.name)
+    const safeFileName = getTestSuiteFilesystemKey(testSuite.name)
 
     const featuresBaseDir = getAutomationFeaturesDir()
     const moduleDir = join(featuresBaseDir, modulePath.substring(1))
@@ -295,7 +242,7 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
         const moduleDir = join(featuresBaseDir, modulePath.substring(1))
         await fs.mkdir(moduleDir, { recursive: true })
 
-        const safeFileName = generateSafeFileName(testSuite.name)
+        const safeFileName = getTestSuiteFilesystemKey(testSuite.name)
         const featureFilePath = join(moduleDir, `${safeFileName}.feature`)
 
         await fs.writeFile(featureFilePath, featureContent, 'utf8')
@@ -311,11 +258,3 @@ export async function regenerateAllFeatureFiles(): Promise<string[]> {
     throw error
   }
 }
-
-function generateSafeFileName(testSuiteName: string): string {
-  return testSuiteName
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .replace(/-+/g, '-')
-}