codeceptjs 3.7.5-beta.9 → 3.7.6-beta.1

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

@@ -1,218 +0,0 @@
-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}`)
-
-  // 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)
-    }
-  })
-
-  // If we have specific test files, use them
-  if (testsByFile.size > 0) {
-    for (const [file, tests] of testsByFile) {
-      if (options.grep) {
-        // If grep is specified, combine with file pattern
-        testPatterns.push(file)
-      } else {
-        // Try to be more specific with test titles if possible
-        testPatterns.push(file)
-      }
-    }
-  } else {
-    // Fallback: use test titles with grep
-    const testTitles = failedTestsData.tests.map(test => test.title).filter(Boolean)
-    if (testTitles.length > 0) {
-      // Create a regex pattern to match any of the failed test titles
-      const grepPattern = testTitles.map(title => title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')
-      options.grep = grepPattern
-    }
-  }
-
-  // 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,
-  }
-
-  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 (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()
-  }
-}

package/lib/plugin/failedTestsTracker.js

@@ -1,374 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const event = require('../event')
-const output = require('../output')
-const store = require('../store')
-
-const defaultConfig = {
-  enabled: true,
-  outputFile: 'failed-tests.json',
-  clearOnSuccess: true,
-  includeStackTrace: true,
-  includeMetadata: true,
-}
-
-/**
- * Failed Tests Tracker Plugin for CodeceptJS
- *
- * Tracks failed tests and saves them to a file for later re-execution.
- *
- * ## Configuration
- *
- * ```js
- * "plugins": {
- *    "failedTestsTracker": {
- *      "enabled": true,
- *      "outputFile": "failed-tests.json",
- *      "clearOnSuccess": true,
- *      "includeStackTrace": true,
- *      "includeMetadata": true
- *    }
- * }
- * ```
- *
- * @param {object} config plugin configuration
- */
-module.exports = function (config) {
-  const options = { ...defaultConfig, ...config }
-  let failedTests = []
-  let allTestsPassed = true
-  let workerFailedTests = new Map() // Track failed tests from workers
-
-  // Track test failures - only when not using workers
-  event.dispatcher.on(event.test.failed, test => {
-    // Skip collection in worker threads to avoid duplicates
-    try {
-      const { isMainThread } = require('worker_threads')
-      if (!isMainThread) return
-    } catch (e) {
-      // worker_threads not available, continue
-    }
-
-    if (store.hasWorkers) return // Skip if running with workers
-
-    // Only collect on final failure (when retries are exhausted or no retries configured)
-    const currentRetry = test._currentRetry || 0
-    const maxRetries = typeof test.retries === 'function' ? test.retries() : (test.retries || 0)
-    
-    // Only add to failed tests if this is the final attempt
-    if (currentRetry >= maxRetries) {
-      allTestsPassed = false
-
-      const failedTest = {
-        title: test.title,
-        fullTitle: test.fullTitle(),
-        file: test.file || (test.parent && test.parent.file),
-        uid: test.uid,
-        timestamp: new Date().toISOString(),
-      }
-
-      // Add parent suite information
-      if (test.parent) {
-        failedTest.suite = test.parent.title
-        failedTest.suiteFile = test.parent.file
-      }
-
-      // Add error information if available
-      if (test.err && options.includeStackTrace) {
-        failedTest.error = {
-          message: test.err.message || 'Test failed',
-          stack: test.err.stack || '',
-          name: test.err.name || 'Error',
-        }
-      }
-
-      // Add metadata if available
-      if (options.includeMetadata) {
-        failedTest.metadata = {
-          tags: test.tags || [],
-          meta: test.meta || {},
-          opts: test.opts || {},
-          duration: test.duration || 0,
-          // Only include retries if it represents actual retry attempts, not the config value
-          ...(test._currentRetry > 0 && { actualRetries: test._currentRetry }),
-          ...(maxRetries > 0 && maxRetries !== -1 && { maxRetries: maxRetries }),
-        }
-      }
-
-      // Add BDD/Gherkin information if available
-      if (test.parent && test.parent.feature) {
-        failedTest.bdd = {
-          feature: test.parent.feature.name || test.parent.title,
-          scenario: test.title,
-          featureFile: test.parent.file,
-        }
-      }
-
-      failedTests.push(failedTest)
-      output.print(`Failed Tests Tracker: Recorded failed test - ${test.title}`)
-    }
-  })
-
-  // Handle test completion and save failed tests
-  event.dispatcher.on(event.all.result, (result) => {
-    
-    // Respect CodeceptJS output directory like other plugins
-    const outputDir = global.output_dir || './output'
-    const outputPath = path.isAbsolute(options.outputFile)
-      ? options.outputFile
-      : path.resolve(outputDir, options.outputFile)
-    let allFailedTests = [...failedTests]
-
-    // Collect failed tests from result (both worker and single-process modes)
-    if (result) {
-      let resultFailedTests = []
-      
-      // Worker mode: result.tests
-      if (store.hasWorkers && result.tests) {
-        resultFailedTests = result.tests.filter(test => test.state === 'failed' || test.err)
-      }
-      // Single-process mode: result._failures or result._tests
-      else if (!store.hasWorkers && (result._failures || result._tests)) {
-        if (result._failures && result._failures.length > 0) {
-          resultFailedTests = result._failures.map(failure => failure.test || failure)
-        } else if (result._tests) {
-          resultFailedTests = result._tests.filter(test => test.state === 'failed' || test.err)
-        }
-      }
-
-      // Use a Set to track unique test identifiers to prevent duplicates
-      const existingTestIds = new Set(allFailedTests.map(test => test.uid || `${test.file}:${test.title}`))
-
-      resultFailedTests.forEach(test => {
-        // Create unique identifier for deduplication
-        const testId = test.uid || `${test.file || 'unknown'}:${test.title}`
-
-        // Skip if we already have this test
-        if (existingTestIds.has(testId)) {
-          return
-        }
-
-        const failedTest = {
-          title: test.title,
-          fullTitle: test.fullTitle || test.title,
-          file: test.file || 'unknown',
-          uid: test.uid,
-          timestamp: new Date().toISOString(),
-        }
-
-        // Add parent suite information
-        if (test.parent) {
-          failedTest.suite = test.parent.title
-          failedTest.suiteFile = test.parent.file
-        }
-
-        // Add error information if available
-        if (test.err && options.includeStackTrace) {
-          failedTest.error = {
-            message: test.err.message || 'Test failed',
-            stack: test.err.stack || '',
-            name: test.err.name || 'Error',
-          }
-        }
-
-        // Add metadata if available
-        if (options.includeMetadata) {
-          failedTest.metadata = {
-            tags: test.tags || [],
-            meta: test.meta || {},
-            opts: test.opts || {},
-            duration: test.duration || 0,
-            retries: test.retries || 0,
-          }
-        }
-
-        // Add BDD/Gherkin information if available
-        if (test.parent && test.parent.feature) {
-          failedTest.bdd = {
-            feature: test.parent.feature.name || test.parent.title,
-            scenario: test.title,
-            featureFile: test.parent.file,
-          }
-        }
-
-        allFailedTests.push(failedTest)
-        existingTestIds.add(testId)
-      })
-
-      output.print(`Failed Tests Tracker: Collected ${resultFailedTests.length} failed tests from result`)
-    }
-
-    if (allFailedTests.length === 0) {
-      if (options.clearOnSuccess && fs.existsSync(outputPath)) {
-        try {
-          fs.unlinkSync(outputPath)
-          output.print(`Failed Tests Tracker: Cleared previous failed tests file (all tests passed)`)
-        } catch (error) {
-          output.print(`Failed Tests Tracker: Could not clear failed tests file: ${error.message}`)
-        }
-      } else {
-        output.print(`Failed Tests Tracker: No failed tests to save`)
-      }
-      return
-    }
-
-    const failedTestsData = {
-      timestamp: new Date().toISOString(),
-      totalFailedTests: allFailedTests.length,
-      codeceptVersion: require('../codecept').version(),
-      tests: allFailedTests,
-    }
-
-    try {
-      // Ensure directory exists
-      const dir = path.dirname(outputPath)
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true })
-      }
-
-      fs.writeFileSync(outputPath, JSON.stringify(failedTestsData, null, 2))
-      output.print(`Failed Tests Tracker: Saved ${allFailedTests.length} failed tests to ${outputPath}`)
-    } catch (error) {
-      output.print(`Failed Tests Tracker: Failed to save failed tests: ${error.message}`)
-    }
-  })
-
-  // Reset state for new test runs
-  event.dispatcher.on(event.all.before, () => {
-    failedTests = []
-    allTestsPassed = true
-    workerFailedTests.clear()
-  })
-
-  // Handle worker mode - listen to workers.result event for consolidated results
-  event.dispatcher.on(event.workers.result, (result) => {
-    // Respect CodeceptJS output directory like other plugins
-    const outputDir = global.output_dir || './output'
-    const outputPath = path.isAbsolute(options.outputFile)
-      ? options.outputFile
-      : path.resolve(outputDir, options.outputFile)
-
-    let allFailedTests = []
-
-    // In worker mode, collect failed tests from consolidated result
-    if (result && result.tests) {
-      const workerFailedTests = result.tests.filter(test => test.state === 'failed' || test.err)
-
-      workerFailedTests.forEach(test => {
-        // Extract file path from test title or error stack trace as fallback
-        let filePath = test.file || test.parent?.file || 'unknown'
-        
-        // If still unknown, try to extract from error stack trace
-        if (filePath === 'unknown' && test.err && test.err.stack) {
-          // Try multiple regex patterns for different stack trace formats
-          const patterns = [
-            /at.*\(([^)]+\.js):\d+:\d+\)/,  // Standard format
-            /at.*\(.*[\/\\]([^\/\\]+\.js):\d+:\d+\)/,  // With path separators
-            /\(([^)]*\.js):\d+:\d+\)/,  // Simpler format
-            /([^\/\\]+\.js):\d+:\d+/,   // Just filename with line numbers
-          ]
-          
-          for (const pattern of patterns) {
-            const stackMatch = test.err.stack.match(pattern)
-            if (stackMatch && stackMatch[1]) {
-              const absolutePath = stackMatch[1]
-              const relativePath = absolutePath.replace(process.cwd() + '/', '').replace(/^.*[\/\\]/, '')
-              filePath = relativePath
-              break
-            }
-          }
-        }
-        
-        // If still unknown, try to extract from test context or use test file pattern
-        if (filePath === 'unknown') {
-          // Look for common test file patterns in the test title or fullTitle
-          const fullTitle = test.fullTitle || test.title
-          if (fullTitle && fullTitle.includes('checkout')) {
-            filePath = 'checkout_test.js'
-          } else if (fullTitle && fullTitle.includes('github')) {
-            filePath = 'github_test.js'
-          }
-        }
-        
-        const failedTest = {
-          title: test.title,
-          fullTitle: test.fullTitle || test.title,
-          file: filePath,
-          uid: test.uid,
-          timestamp: new Date().toISOString(),
-        }
-
-        // Add parent suite information
-        if (test.parent) {
-          failedTest.suite = test.parent.title
-          failedTest.suiteFile = test.parent.file
-        }
-
-        // Add error information if available
-        if (test.err && options.includeStackTrace) {
-          failedTest.error = {
-            message: test.err.message || 'Test failed',
-            stack: test.err.stack || '',
-            name: test.err.name || 'Error',
-          }
-        }
-
-        // Add metadata if available
-        if (options.includeMetadata) {
-          failedTest.metadata = {
-            tags: test.tags || [],
-            meta: test.meta || {},
-            opts: test.opts || {},
-            duration: test.duration || 0,
-            retries: test.retries || 0,
-          }
-        }
-
-        // Add BDD/Gherkin information if available
-        if (test.parent && test.parent.feature) {
-          failedTest.bdd = {
-            feature: test.parent.feature.name || test.parent.title,
-            scenario: test.title,
-            featureFile: test.parent.file,
-          }
-        }
-
-        allFailedTests.push(failedTest)
-      })
-
-      output.print(`Failed Tests Tracker: Collected ${allFailedTests.length - failedTests.length} failed tests from workers`)
-    }
-
-    if (allFailedTests.length === 0) {
-      if (options.clearOnSuccess && fs.existsSync(outputPath)) {
-        try {
-          fs.unlinkSync(outputPath)
-          output.print(`Failed Tests Tracker: Cleared previous failed tests file (all tests passed)`)
-        } catch (error) {
-          output.print(`Failed Tests Tracker: Could not clear failed tests file: ${error.message}`)
-        }
-      }
-      return
-    }
-
-    // Save failed tests to file
-    try {
-      const failedTestsData = {
-        timestamp: new Date().toISOString(),
-        totalFailed: allFailedTests.length,
-        tests: allFailedTests,
-      }
-
-      // Ensure output directory exists
-      const dir = path.dirname(outputPath)
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true })
-      }
-
-      fs.writeFileSync(outputPath, JSON.stringify(failedTestsData, null, 2))
-      output.print(`Failed Tests Tracker: Saved ${allFailedTests.length} failed tests to ${outputPath}`)
-    } catch (error) {
-      output.print(`Failed Tests Tracker: Failed to save failed tests: ${error.message}`)
-    }
-  })
-}