codeceptjs 3.7.5-beta.1 → 3.7.5-beta.10

package/bin/codecept.js

@@ -296,6 +296,29 @@ program
 
   .action(require('../lib/command/run-rerun'))
 
+program
+  .command('run-failed-tests')
+  .description('Re-run tests that failed in the previous test run')
+  .option(commandFlags.config.flag, commandFlags.config.description)
+  .option(commandFlags.profile.flag, commandFlags.profile.description)
+  .option(commandFlags.verbose.flag, commandFlags.verbose.description)
+  .option(commandFlags.debug.flag, commandFlags.debug.description)
+  .option(commandFlags.steps.flag, commandFlags.steps.description)
+  .option('-o, --override [value]', 'override current config options')
+  .option('-f, --file [path]', 'path to failed tests file (default: ./failed-tests.json)')
+  .option('-g, --grep <pattern>', 'only run failed tests matching <pattern>')
+  .option('-p, --plugins <k=v,k2=v2,...>', 'enable plugins, comma-separated')
+  .option('--features', 'run only *.feature files and skip tests')
+  .option('--tests', 'run only JS test files and skip features')
+  .option('--colors', 'force enabling of colors')
+  .option('--no-colors', 'force disabling of colors')
+  .option('-R, --reporter <name>', 'specify the reporter to use')
+  .option('-O, --reporter-options <k=v,k2=v2,...>', 'reporter-specific options')
+  .option('--workers <number>', 'run failed tests in parallel using specified number of workers')
+  .option('--suites', 'parallel execution of suites not single tests (when using --workers)')
+  .option('--by <strategy>', 'test distribution strategy when using --workers: "test", "suite", or "pool"')
+  .action(errorHandler(require('../lib/command/run-failed-tests')))
+
 program.on('command:*', cmd => {
   console.log(`\nUnknown command ${cmd}\n`)
   program.outputHelp()

package/lib/command/run-failed-tests.js

@@ -0,0 +1,263 @@
+const fs = require('fs')
+const path = require('path')
+const { getConfig, printError, getTestRoot, createOutputDir } = require('./utils')
+const Config = require('../config')
+const store = require('../store')
+const Codecept = require('../codecept')
+const output = require('../output')
+const Workers = require('../workers')
+const { tryOrDefault } = require('../utils')
+
+module.exports = async function (options) {
+  // registering options globally to use in config
+  if (options.profile) {
+    process.env.profile = options.profile
+  }
+  if (options.verbose || options.debug) store.debugMode = true
+
+  const configFile = options.config
+  let config = getConfig(configFile)
+  
+  if (options.override) {
+    config = Config.append(JSON.parse(options.override))
+  }
+  
+  const testRoot = getTestRoot(configFile)
+  createOutputDir(config, testRoot)
+
+  // Determine failed tests file path - respect CodeceptJS output directory
+  const failedTestsFile = options.file || 'failed-tests.json'
+  const failedTestsPath = path.isAbsolute(failedTestsFile)
+    ? failedTestsFile
+    : path.resolve(global.output_dir || './output', failedTestsFile)
+
+  // Check if failed tests file exists
+  if (!fs.existsSync(failedTestsPath)) {
+    output.error(`Failed tests file not found: ${failedTestsPath}`)
+    output.print('Run tests first to generate a failed tests file, or specify a different file with --file option')
+    process.exitCode = 1
+    return
+  }
+
+  let failedTestsData
+  try {
+    const fileContent = fs.readFileSync(failedTestsPath, 'utf8')
+    failedTestsData = JSON.parse(fileContent)
+  } catch (error) {
+    output.error(`Failed to read or parse failed tests file: ${error.message}`)
+    process.exitCode = 1
+    return
+  }
+
+  if (!failedTestsData.tests || failedTestsData.tests.length === 0) {
+    output.print('No failed tests found in the file')
+    return
+  }
+
+  output.print(`Found ${failedTestsData.tests.length} failed tests from ${failedTestsData.timestamp}`)
+
+  // Debug: Show what's in the failed tests data
+  if (options.verbose) {
+    output.print('\nFailed tests data structure:')
+    failedTestsData.tests.forEach((test, index) => {
+      output.print(`  ${index + 1}. Title: "${test.title}", UID: "${test.uid}", File: "${test.file}"`)
+    })
+    output.print('')
+  }
+
+  // Build test patterns from failed tests
+  const testPatterns = []
+  const testsByFile = new Map()
+
+  // Group tests by file for more efficient execution
+  failedTestsData.tests.forEach(test => {
+    if (test.file) {
+      if (!testsByFile.has(test.file)) {
+        testsByFile.set(test.file, [])
+      }
+      testsByFile.get(test.file).push(test)
+    }
+  })
+
+  // Build precise test selection from failed tests
+  if (testsByFile.size > 0) {
+    // Use file paths for loading tests
+    for (const [file, tests] of testsByFile) {
+      testPatterns.push(file)
+    }
+    
+    // Extract exact test UIDs for precise filtering
+    const failedTestUIDs = failedTestsData.tests
+      .map(test => test.uid)
+      .filter(Boolean)
+    
+    if (failedTestUIDs.length > 0) {
+      // Pass UIDs to options for precise test filtering
+      options.tests = failedTestUIDs
+      output.print(`Targeting ${failedTestUIDs.length} specific failed tests by UID`)
+    } else {
+      // Fallback to title-based grep if no UIDs available
+      const testTitles = failedTestsData.tests.map(test => test.title).filter(Boolean)
+      if (testTitles.length > 0) {
+        const grepPattern = testTitles.map(title => `^${title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`).join('|')
+        options.grep = grepPattern
+        output.print(`Targeting failed tests by title pattern (no UIDs available)`)
+      }
+    }
+  } else {
+    // Fallback: use test titles with exact match grep
+    const testTitles = failedTestsData.tests.map(test => test.title).filter(Boolean)
+    if (testTitles.length > 0) {
+      const grepPattern = testTitles.map(title => `^${title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`).join('|')
+      options.grep = grepPattern
+      output.print(`Targeting failed tests by title pattern (no file info available)`)
+    }
+  }
+
+  // Check if user wants to run with workers
+  if (options.workers) {
+    await runWithWorkers(config, options, testPatterns, failedTestsData)
+  } else {
+    await runWithoutWorkers(config, options, testPatterns, failedTestsData, testRoot)
+  }
+}
+
+async function runWithWorkers(config, options, testPatterns, failedTestsData) {
+  const numberOfWorkers = parseInt(options.workers, 10)
+  const overrideConfigs = tryOrDefault(() => JSON.parse(options.override || '{}'), {})
+  
+  // Determine test split strategy
+  let by = 'test' // default for failed tests
+  if (options.by) {
+    by = options.by
+  } else if (options.suites) {
+    by = 'suite'
+  }
+
+  // Validate the by option
+  const validStrategies = ['test', 'suite', 'pool']
+  if (!validStrategies.includes(by)) {
+    throw new Error(`Invalid --by strategy: ${by}. Valid options are: ${validStrategies.join(', ')}`)
+  }
+
+  const workerConfig = {
+    by,
+    testConfig: options.config,
+    options,
+    selectedRuns: undefined,
+  }
+
+  // If we have specific test UIDs, override the worker test selection
+  if (options.tests && options.tests.length > 0) {
+    workerConfig.by = 'test' // Force test-level distribution for precise targeting
+    output.print(`Using precise test UID targeting for ${options.tests.length} failed tests`)
+  }
+
+  output.print(`CodeceptJS v${require('../codecept').version()}`)
+  output.print(`Re-running ${failedTestsData.tests.length} failed tests in ${output.styles.bold(numberOfWorkers)} workers...`)
+  output.print()
+  store.hasWorkers = true
+
+  const workers = new Workers(numberOfWorkers, workerConfig)
+  workers.overrideConfig(overrideConfigs)
+
+  // Set up event listeners for worker output
+  workers.on('test.failed', test => {
+    output.test.failed(test)
+  })
+
+  workers.on('test.passed', test => {
+    output.test.passed(test)
+  })
+
+  workers.on('test.skipped', test => {
+    output.test.skipped(test)
+  })
+
+  workers.on('all.result', result => {
+    workers.printResults()
+  })
+
+  try {
+    if (options.verbose || options.debug) store.debugMode = true
+
+    if (options.verbose) {
+      output.print('\nFailed tests to re-run with workers:')
+      failedTestsData.tests.forEach((test, index) => {
+        output.print(`  ${index + 1}. ${test.fullTitle || test.title} (${test.file || 'unknown file'})`)
+        if (test.error && test.error.message) {
+          output.print(`     Error: ${test.error.message}`)
+        }
+      })
+      output.print('')
+      
+      const { getMachineInfo } = require('./info')
+      await getMachineInfo()
+    }
+
+    await workers.bootstrapAll()
+    await workers.run()
+  } catch (err) {
+    printError(err)
+    process.exitCode = 1
+  } finally {
+    await workers.teardownAll()
+  }
+}
+
+async function runWithoutWorkers(config, options, testPatterns, failedTestsData, testRoot) {
+  const codecept = new Codecept(config, options)
+
+  try {
+    codecept.init(testRoot)
+    await codecept.bootstrap()
+
+    // Load tests - if we have specific patterns, use them, otherwise load all and filter with grep
+    if (testPatterns.length > 0) {
+      codecept.loadTests(testPatterns.join(' '))
+    } else {
+      codecept.loadTests()
+    }
+
+    // If we have specific test UIDs, filter the loaded tests to only include those
+    if (options.tests && options.tests.length > 0) {
+      const Container = require('../container')
+      const mocha = Container.mocha()
+      
+      // Filter suites to only include tests with matching UIDs
+      for (const suite of mocha.suite.suites) {
+        suite.tests = suite.tests.filter(test => options.tests.includes(test.uid))
+      }
+      
+      // Remove empty suites
+      mocha.suite.suites = mocha.suite.suites.filter(suite => suite.tests.length > 0)
+      
+      output.print(`Filtered to ${options.tests.length} specific failed tests by UID`)
+    }
+
+    if (options.verbose) {
+      global.debugMode = true
+      const { getMachineInfo } = require('./info')
+      await getMachineInfo()
+    }
+
+    // Display information about what we're running
+    if (options.verbose) {
+      output.print('\nFailed tests to re-run:')
+      failedTestsData.tests.forEach((test, index) => {
+        output.print(`  ${index + 1}. ${test.fullTitle || test.title} (${test.file || 'unknown file'})`)
+        if (test.error && test.error.message) {
+          output.print(`     Error: ${test.error.message}`)
+        }
+      })
+      output.print('')
+    }
+
+    await codecept.run()
+  } catch (err) {
+    printError(err)
+    process.exitCode = 1
+  } finally {
+    await codecept.teardown()
+  }
+}