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

package/lib/plugin/failedTestsTracker.js

@@ -0,0 +1,411 @@
+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._tests (result._failures contains console log arrays, not test objects)
+      else if (!store.hasWorkers && 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 => {
+        
+        // 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'
+          }
+        }
+
+        // Create unique identifier for deduplication
+        const testId = test.uid || `${filePath}:${test.title}`
+
+        // Skip if we already have this test
+        if (existingTestIds.has(testId)) {
+          return
+        }
+
+        // Extract proper test properties from different test object structures
+        const testTitle = test.title || test.test?.title || (test.fullTitle && test.fullTitle()) || 'Unknown Test'
+        const testFullTitle = test.fullTitle ? (typeof test.fullTitle === 'function' ? test.fullTitle() : test.fullTitle) : testTitle
+        const testUid = test.uid || test.test?.uid || `${filePath}:${testTitle}`
+
+        const failedTest = {
+          title: testTitle,
+          fullTitle: testFullTitle,
+          file: filePath,
+          uid: testUid,
+          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}`)
+    }
+  })
+}

package/lib/workers.js

@@ -310,11 +310,24 @@ class Workers extends EventEmitter {
     const groups = populateGroups(numberOfWorkers)
     let groupCounter = 0
 
+    // If specific tests are provided (e.g., from run-failed-tests), only include those
+    const targetTests = this.options && this.options.tests
+    
     mocha.suite.eachTest(test => {
-      const i = groupCounter % groups.length
       if (test) {
-        groups[i].push(test.uid)
-        groupCounter++
+        // If we have specific target tests, only include matching UIDs
+        if (targetTests && targetTests.length > 0) {
+          if (targetTests.includes(test.uid)) {
+            const i = groupCounter % groups.length
+            groups[i].push(test.uid)
+            groupCounter++
+          }
+        } else {
+          // Default behavior: include all tests
+          const i = groupCounter % groups.length
+          groups[i].push(test.uid)
+          groupCounter++
+        }
       }
     })
     return groups

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.7.5-beta.1",
+  "version": "3.7.5-beta.10",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",

package/typings/promiseBasedTypes.d.ts

@@ -2733,8 +2733,11 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      * @property [recordHar] - record HAR and will be saved to `output/har`. See more of [HAR options](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-har).
      * @property [testIdAttribute = data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
+     * @property [customLocatorStrategies] - custom locator strategies. An object with keys as strategy names and values as JavaScript functions. Example: `{ byRole: (selector, root) => { return root.querySelector(\`[role="\${selector}\"]\`) } }`
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -2772,6 +2775,7 @@ declare namespace CodeceptJS {
         highlightElement?: boolean;
         recordHar?: any;
         testIdAttribute?: string;
+        customLocatorStrategies?: any;
     };
     /**
      * Uses [Playwright](https://github.com/microsoft/playwright) library to run tests inside:
@@ -6112,6 +6116,8 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -6535,17 +6541,6 @@ declare namespace CodeceptJS {
          * {{ react }}
          */
         _locate(): Promise<any>;
-        /**
-         * Get single element by different locator types, including strict locator
-         * Should be used in custom helpers:
-         *
-         * ```js
-         * const element = await this.helpers['Puppeteer']._locateElement({name: 'password'});
-         * ```
-         *
-         * {{ react }}
-         */
-        _locateElement(): Promise<any>;
         /**
          * Find a checkbox by providing human-readable text:
          * NOTE: Assumes the checkable element exists
@@ -6582,17 +6577,6 @@ declare namespace CodeceptJS {
          * @returns WebElement of being used Web helper
          */
         grabWebElements(locator: CodeceptJS.LocatorOrString): Promise<any>;
-        /**
-         * Grab WebElement for given locator
-         * Resumes test execution, so **should be used inside an async function with `await`** operator.
-         *
-         * ```js
-         * const webElement = await I.grabWebElement('#button');
-         * ```
-         * @param locator - element located by CSS|XPath|strict locator.
-         * @returns WebElement of being used Web helper
-         */
-        grabWebElement(locator: CodeceptJS.LocatorOrString): Promise<any>;
         /**
          * Switch focus to a particular tab by its number. It waits tabs loading and then switch tab
          *
@@ -7928,22 +7912,6 @@ declare namespace CodeceptJS {
          */
         flushWebSocketMessages(): Promise<any>;
     }
-    /**
-     * Find elements using Puppeteer's native element discovery methods
-     * Note: Unlike Playwright, Puppeteer's Locator API doesn't have .all() method for multiple elements
-     * @param matcher - Puppeteer context to search within
-     * @param locator - Locator specification
-     * @returns Array of ElementHandle objects
-     */
-    function findElements(matcher: any, locator: any | string): Promise<any[]>;
-    /**
-     * Find a single element using Puppeteer's native element discovery methods
-     * Note: Puppeteer Locator API doesn't have .first() method like Playwright
-     * @param matcher - Puppeteer context to search within
-     * @param locator - Locator specification
-     * @returns Single ElementHandle object
-     */
-    function findElement(matcher: any, locator: any | string): Promise<object>;
     /**
      * ## Configuration
      * @property [endpoint] - API base URL
@@ -7957,6 +7925,8 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -9103,6 +9073,8 @@ declare namespace CodeceptJS {
      * @property [logLevel = silent] - level of logging verbosity. Default: silent. Options: trace | debug | info | warn | error | silent. More info: https://webdriver.io/docs/configuration/#loglevel
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;
@@ -9573,17 +9545,6 @@ declare namespace CodeceptJS {
          * @returns WebElement of being used Web helper
          */
         grabWebElements(locator: CodeceptJS.LocatorOrString): Promise<any>;
-        /**
-         * Grab WebElement for given locator
-         * Resumes test execution, so **should be used inside an async function with `await`** operator.
-         *
-         * ```js
-         * const webElement = await I.grabWebElement('#button');
-         * ```
-         * @param locator - element located by CSS|XPath|strict locator.
-         * @returns WebElement of being used Web helper
-         */
-        grabWebElement(locator: CodeceptJS.LocatorOrString): Promise<any>;
         /**
          * Set [WebDriver timeouts](https://webdriver.io/docs/timeouts.html) in realtime.
          *