codeceptjs 4.0.0-rc.2 → 4.0.0-rc.8

package/lib/utils.js

@@ -150,6 +150,24 @@ export const decodeUrl = function (url) {
   return decodeURIComponent(decodeURIComponent(decodeURIComponent(url)))
 }
 
+export const normalizePath = function (path) {
+  if (path === '' || path === '/') return '/'
+  return path
+    .replace(/\/+/g, '/')
+    .replace(/\/$/, '') || '/'
+}
+
+export const resolveUrl = function (url, baseUrl) {
+  if (!url) return url
+  if (url.indexOf('http') === 0) return url
+  if (!baseUrl) return url
+  try {
+    return new URL(url, baseUrl).href
+  } catch (e) {
+    return url
+  }
+}
+
 export const xpathLocator = {
   /**
    * @param {string} string
@@ -640,6 +658,36 @@ export const base64EncodeFile = function (filePath) {
   return Buffer.from(fs.readFileSync(filePath)).toString('base64')
 }
 
+export const getMimeType = function (fileName) {
+  const ext = path.extname(fileName).toLowerCase()
+  const mimeTypes = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.zip': 'application/zip',
+    '.csv': 'text/csv',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.wav': 'audio/wav',
+  }
+  return mimeTypes[ext] || 'application/octet-stream'
+}
+
 export const markdownToAnsi = function (markdown) {
   return (
     markdown

package/lib/workers.js

@@ -28,7 +28,7 @@ const pathToWorker = path.join(__dirname, 'command', 'workers', 'runTests.js')
 
 const initializeCodecept = async (configPath, options = {}) => {
   const config = await mainConfig.load(configPath || '.')
-  const codecept = new Codecept(config, options)
+  const codecept = new Codecept(config, { ...options, skipDefaultListeners: true })
   await codecept.init(getTestRoot(configPath))
   codecept.loadTests()
 
@@ -625,13 +625,32 @@ class Workers extends EventEmitter {
 
           break
         case event.suite.before:
-          this.emit(event.suite.before, deserializeSuite(message.data))
+          {
+            const suite = deserializeSuite(message.data)
+            this.emit(event.suite.before, suite)
+            event.dispatcher.emit(event.suite.before, suite)
+          }
+          break
+        case event.suite.after:
+          {
+            const suite = deserializeSuite(message.data)
+            this.emit(event.suite.after, suite)
+            event.dispatcher.emit(event.suite.after, suite)
+          }
           break
         case event.test.before:
-          this.emit(event.test.before, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.before, test)
+            event.dispatcher.emit(event.test.before, test)
+          }
           break
         case event.test.started:
-          this.emit(event.test.started, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.started, test)
+            event.dispatcher.emit(event.test.started, test)
+          }
           break
         case event.test.failed:
           // For hook failures, emit immediately as there won't be a test.finished event
@@ -645,7 +664,11 @@ class Workers extends EventEmitter {
           // Skip individual passed events - we'll emit based on finished state
           break
         case event.test.skipped:
-          this.emit(event.test.skipped, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.skipped, test)
+            event.dispatcher.emit(event.test.skipped, test)
+          }
           break
         case event.test.finished:
           // Handle different types of test completion properly
@@ -674,28 +697,47 @@ class Workers extends EventEmitter {
               }
             }
 
-            this.emit(event.test.finished, deserializeTest(data))
+            const test = deserializeTest(data)
+            this.emit(event.test.finished, test)
+            event.dispatcher.emit(event.test.finished, test)
           }
           break
         case event.test.after:
-          this.emit(event.test.after, deserializeTest(message.data))
+          {
+            const test = deserializeTest(message.data)
+            this.emit(event.test.after, test)
+            event.dispatcher.emit(event.test.after, test)
+          }
           break
         case event.step.finished:
           this.emit(event.step.finished, message.data)
+          event.dispatcher.emit(event.step.finished, message.data)
           break
         case event.step.started:
           this.emit(event.step.started, message.data)
+          event.dispatcher.emit(event.step.started, message.data)
           break
         case event.step.passed:
           this.emit(event.step.passed, message.data)
+          event.dispatcher.emit(event.step.passed, message.data)
           break
         case event.step.failed:
           this.emit(event.step.failed, message.data, message.data.error)
+          event.dispatcher.emit(event.step.failed, message.data, message.data.error)
           break
         case event.hook.failed:
           // Hook failures are already reported as test failures by the worker
           // Just emit the hook.failed event for listeners
           this.emit(event.hook.failed, message.data)
+          event.dispatcher.emit(event.hook.failed, message.data)
+          break
+        case event.hook.passed:
+          this.emit(event.hook.passed, message.data)
+          event.dispatcher.emit(event.hook.passed, message.data)
+          break
+        case event.hook.finished:
+          this.emit(event.hook.finished, message.data)
+          event.dispatcher.emit(event.hook.finished, message.data)
           break
       }
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.0-rc.2",
+  "version": "4.0.0-rc.8",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
@@ -44,9 +44,10 @@
     "./store": "./lib/store.js"
   },
   "bin": {
-    "codeceptjs": "./bin/codecept.js"
+    "codeceptjs": "./bin/codecept.js",
+    "codeceptjs-mcp": "./bin/mcp-server.js"
   },
-  "repository": "Codeception/codeceptjs",
+  "repository": "codeceptjs/CodeceptJS",
   "scripts": {
     "test-server": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010 --read-only",
     "test-server:writable": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010",
@@ -90,6 +91,7 @@
     "@cucumber/cucumber-expressions": "18",
     "@cucumber/gherkin": "38.0.0",
     "@cucumber/messages": "32.0.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@xmldom/xmldom": "0.9.8",
     "acorn": "8.15.0",
     "ai": "^6.0.43",

package/lib/listener/enhancedGlobalRetry.js

@@ -1,110 +0,0 @@
-import event from '../event.js'
-import output from '../output.js'
-import Config from '../config.js'
-import { isNotSet } from '../utils.js'
-
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
-
-/**
- * Priority levels for retry mechanisms (higher number = higher priority)
- * This ensures consistent behavior when multiple retry mechanisms are active
- */
-const RETRY_PRIORITIES = {
-  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
-  STEP_PLUGIN: 50, // retryFailedStep plugin
-  SCENARIO_CONFIG: 30, // Global scenario retry config
-  FEATURE_CONFIG: 20, // Global feature retry config
-  HOOK_CONFIG: 10, // Hook retry config - lowest priority
-}
-
-/**
- * Enhanced global retry mechanism that coordinates with other retry types
- */
-export default function () {
-  event.dispatcher.on(event.suite.before, suite => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // is number - apply as feature-level retry
-      const retryNum = +retryConfig
-      output.log(`[Global Retry] Feature retries: ${retryNum}`)
-
-      // Only set if not already set by higher priority mechanism
-      if (isNotSet(suite.retries())) {
-        suite.retries(retryNum)
-        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue
-      }
-
-      // Handle hook retries with priority awareness
-      hooks
-        .filter(hook => !!config[hook])
-        .forEach(hook => {
-          const retryKey = `retry${hook}`
-          if (isNotSet(suite.opts[retryKey])) {
-            suite.opts[retryKey] = config[hook]
-            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
-          }
-        })
-
-      // Handle feature-level retries
-      if (config.Feature) {
-        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
-          suite.retries(config.Feature)
-          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
-        }
-      }
-    }
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // Only set if not already set by higher priority mechanism
-      if (test.retries() === -1) {
-        test.retries(retryConfig)
-        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    retryConfig = retryConfig.filter(config => !!config.Scenario)
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue
-      }
-
-      if (config.Scenario) {
-        // Respect priority system
-        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
-          test.retries(config.Scenario)
-          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-          output.log(`[Global Retry] Scenario retries: ${config.Scenario}`)
-        }
-      }
-    }
-  })
-}
-
-// Export priority constants for use by other retry mechanisms
-export { RETRY_PRIORITIES }

package/lib/plugin/enhancedRetryFailedStep.js

@@ -1,99 +0,0 @@
-import event from '../event.js'
-import recorder from '../recorder.js'
-import store from '../store.js'
-import output from '../output.js'
-import { RETRY_PRIORITIES } from '../retryCoordinator.js'
-
-const defaultConfig = {
-  retries: 3,
-  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
-  factor: 1.5,
-  ignoredSteps: [],
-}
-
-/**
- * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
- *
- * This plugin provides step-level retries and coordinates with global retry settings
- * to avoid conflicts and provide predictable behavior.
- */
-export default config => {
-  config = Object.assign({}, defaultConfig, config)
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
-  const customWhen = config.when
-
-  let enableRetry = false
-
-  const when = err => {
-    if (!enableRetry) return false
-    if (store.debugMode) return false
-    if (!store.autoRetries) return false
-    if (customWhen) return customWhen(err)
-    return true
-  }
-  config.when = when
-
-  event.dispatcher.on(event.step.started, step => {
-    // if a step is ignored - return
-    for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return
-      if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
-    }
-    enableRetry = true // enable retry for a step
-  })
-
-  event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    // pass disableRetryFailedStep is a preferred way to disable retries
-    // test.disableRetryFailedStep is used for backward compatibility
-    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
-      store.autoRetries = false
-      output.log(`[Step Retry] Disabled for test: ${test.title}`)
-      return // disable retry when a test is not active
-    }
-
-    // Check if step retries should be disabled due to higher priority scenario retries
-    const scenarioRetries = test.retries()
-    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
-    const scenarioPriority = test.opts.retryPriority || 0
-
-    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
-      // Scenario retries are configured with higher or equal priority
-      // Option 1: Disable step retries (conservative approach)
-      store.autoRetries = false
-      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
-      return
-
-      // Option 2: Reduce step retries to avoid excessive total retries
-      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
-      // config.retries = reducedStepRetries
-      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
-    }
-
-    // this option is used to set the retries inside _before() block of helpers
-    store.autoRetries = true
-    test.opts.conditionalRetries = config.retries
-    test.opts.stepRetryPriority = stepRetryPriority
-
-    recorder.retry(config)
-
-    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
-  })
-
-  // Add coordination info for debugging
-  event.dispatcher.on(event.test.finished, test => {
-    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
-      const stepRetries = test.opts.conditionalRetries || 0
-      const scenarioRetries = test.retries() || 0
-
-      if (stepRetries > 0 && scenarioRetries > 0) {
-        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
-      }
-    }
-  })
-}