codeceptjs 4.0.2-beta.8 → 4.0.2

package/lib/utils/typescript.js

@@ -1,5 +1,60 @@
 import fs from 'fs'
 import path from 'path'
+import { pathToFileURL } from 'url'
+
+/**
+ * Load tsconfig.json if it exists
+ * @param {string} tsConfigPath - Path to tsconfig.json
+ * @returns {object|null} - Parsed tsconfig or null
+ */
+function loadTsConfig(tsConfigPath) {
+  if (!fs.existsSync(tsConfigPath)) {
+    return null
+  }
+
+  try {
+    const tsConfigContent = fs.readFileSync(tsConfigPath, 'utf8')
+    return JSON.parse(tsConfigContent)
+  } catch (err) {
+    return null
+  }
+}
+
+/**
+ * Resolve TypeScript path alias to actual file path
+ * @param {string} importPath - Import path with alias (e.g., '#config/urls')
+ * @param {object} tsConfig - Parsed tsconfig.json
+ * @param {string} configDir - Directory containing tsconfig.json
+ * @returns {string|null} - Resolved file path or null if not an alias
+ */
+function resolveTsPathAlias(importPath, tsConfig, configDir) {
+  if (!tsConfig || !tsConfig.compilerOptions || !tsConfig.compilerOptions.paths) {
+    return null
+  }
+
+  const paths = tsConfig.compilerOptions.paths
+
+  for (const [pattern, targets] of Object.entries(paths)) {
+    if (!targets || targets.length === 0) {
+      continue
+    }
+
+    const patternRegex = new RegExp(
+      '^' + pattern.replace(/\*/g, '(.*)') + '$'
+    )
+    const match = importPath.match(patternRegex)
+
+    if (match) {
+      const wildcard = match[1] || ''
+      const target = targets[0]
+      const resolvedTarget = target.replace(/\*/g, wildcard)
+
+      return path.resolve(configDir, resolvedTarget)
+    }
+  }
+
+  return null
+}
 
 /**
  * Transpile TypeScript files to ES modules with CommonJS shim support
@@ -108,6 +163,22 @@ const __dirname = __dirname_fn(__filename);
   const transpiledFiles = new Map()
   const baseDir = path.dirname(mainFilePath)
 
+  // Try to find tsconfig.json by walking up the directory tree
+  let tsConfigPath = path.join(baseDir, 'tsconfig.json')
+  let configDir = baseDir
+  let searchDir = baseDir
+
+  while (!fs.existsSync(tsConfigPath) && searchDir !== path.dirname(searchDir)) {
+    searchDir = path.dirname(searchDir)
+    tsConfigPath = path.join(searchDir, 'tsconfig.json')
+    if (fs.existsSync(tsConfigPath)) {
+      configDir = searchDir
+      break
+    }
+  }
+
+  const tsConfig = loadTsConfig(tsConfigPath)
+
   // Recursive function to transpile a file and all its TypeScript dependencies
   const transpileFileAndDeps = (filePath) => {
     // Already transpiled, skip
@@ -118,21 +189,36 @@ const __dirname = __dirname_fn(__filename);
     // Transpile this file
     let jsContent = transpileTS(filePath)
 
-    // Find all relative TypeScript imports in this file
-    const importRegex = /from\s+['"](\.[^'"]+?)(?:\.ts)?['"]/g
+    // Find all TypeScript imports in this file (both ESM imports and require() calls)
+    const importRegex = /from\s+['"]([^'"]+?)['"]/g
+    const requireRegex = /require\s*\(\s*['"]([^'"]+?)['"]\s*\)/g
     let match
     const imports = []
 
     while ((match = importRegex.exec(jsContent)) !== null) {
-      imports.push(match[1])
+      imports.push({ path: match[1], type: 'import' })
+    }
+
+    while ((match = requireRegex.exec(jsContent)) !== null) {
+      imports.push({ path: match[1], type: 'require' })
     }
 
     // Get the base directory for this file
     const fileBaseDir = path.dirname(filePath)
 
     // Recursively transpile each imported TypeScript file
-    for (const relativeImport of imports) {
-      let importedPath = path.resolve(fileBaseDir, relativeImport)
+    for (const { path: importPath } of imports) {
+      let importedPath = importPath
+
+      // Check if this is a path alias
+      const resolvedAlias = resolveTsPathAlias(importPath, tsConfig, configDir)
+      if (resolvedAlias) {
+        importedPath = resolvedAlias
+      } else if (importPath.startsWith('.')) {
+        importedPath = path.resolve(fileBaseDir, importPath)
+      } else {
+        continue
+      }
 
       // Handle .js extensions that might actually be .ts files
       if (importedPath.endsWith('.js')) {
@@ -153,11 +239,17 @@ const __dirname = __dirname_fn(__filename);
         if (fs.existsSync(tsPath)) {
           importedPath = tsPath
         } else {
-          // Try .js extension as well
-          const jsPath = importedPath + '.js'
-          if (fs.existsSync(jsPath)) {
-            // Skip .js files, they don't need transpilation
-            continue
+          // Try index.ts for directory imports
+          const indexTsPath = path.join(importedPath, 'index.ts')
+          if (fs.existsSync(indexTsPath)) {
+            importedPath = indexTsPath
+          } else {
+            // Try .js extension as well
+            const jsPath = importedPath + '.js'
+            if (fs.existsSync(jsPath)) {
+              // Skip .js files, they don't need transpilation
+              continue
+            }
           }
         }
       }
@@ -170,24 +262,45 @@ const __dirname = __dirname_fn(__filename);
 
     // After all dependencies are transpiled, rewrite imports in this file
     jsContent = jsContent.replace(
-      /from\s+['"](\.[^'"]+?)(?:\.ts)?['"]/g,
+      /from\s+['"]([^'"]+?)['"]/g,
       (match, importPath) => {
-        let resolvedPath = path.resolve(fileBaseDir, importPath)
+        let resolvedPath = importPath
         const originalExt = path.extname(importPath)
 
+        // Check if this is a path alias
+        const resolvedAlias = resolveTsPathAlias(importPath, tsConfig, configDir)
+        if (resolvedAlias) {
+          resolvedPath = resolvedAlias
+        } else if (importPath.startsWith('.')) {
+          resolvedPath = path.resolve(fileBaseDir, importPath)
+        } else {
+          return match
+        }
+
+        // If resolved path is a directory, try index.ts
+        if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
+          const indexPath = path.join(resolvedPath, 'index.ts')
+          if (fs.existsSync(indexPath) && transpiledFiles.has(indexPath)) {
+            const tempFile = transpiledFiles.get(indexPath)
+            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+            if (!relPath.startsWith('.')) {
+              return `from './${relPath}'`
+            }
+            return `from '${relPath}'`
+          }
+        }
+
         // Handle .js extension that might be .ts
         if (resolvedPath.endsWith('.js')) {
           const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
           if (transpiledFiles.has(tsVersion)) {
             const tempFile = transpiledFiles.get(tsVersion)
             const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
-            // Ensure the path starts with ./
             if (!relPath.startsWith('.')) {
               return `from './${relPath}'`
             }
             return `from '${relPath}'`
           }
-          // Keep .js extension as-is (might be a real .js file)
           return match
         }
 
@@ -198,18 +311,24 @@ const __dirname = __dirname_fn(__filename);
         if (transpiledFiles.has(tsPath)) {
           const tempFile = transpiledFiles.get(tsPath)
           const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
-          // Ensure the path starts with ./
           if (!relPath.startsWith('.')) {
             return `from './${relPath}'`
           }
           return `from '${relPath}'`
         }
 
-        // If the import doesn't have a standard module extension (.js, .mjs, .cjs, .json)
-        // add .js for ESM compatibility
-        // This handles cases where:
-        // 1. Import has no real extension (e.g., "./utils" or "./helper")
-        // 2. Import has a non-standard extension that's part of the name (e.g., "./abstract.helper")
+        // Try index.ts for directory imports
+        const indexTsPath = path.join(resolvedPath, 'index.ts')
+        if (transpiledFiles.has(indexTsPath)) {
+          const tempFile = transpiledFiles.get(indexTsPath)
+          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+          if (!relPath.startsWith('.')) {
+            return `from './${relPath}'`
+          }
+          return `from '${relPath}'`
+        }
+
+        // If the import doesn't have a standard module extension, add .js for ESM compatibility
         const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
         const hasStandardExtension = standardExtensions.includes(originalExt.toLowerCase())
 
@@ -217,7 +336,50 @@ const __dirname = __dirname_fn(__filename);
           return match.replace(importPath, importPath + '.js')
         }
 
-        // Otherwise, keep the import as-is
+        return match
+      }
+    )
+
+    // Also rewrite require() calls to point to transpiled TypeScript files
+    jsContent = jsContent.replace(
+      /require\s*\(\s*['"]([^'"]+?)['"]\s*\)/g,
+      (match, requirePath) => {
+        let resolvedPath = requirePath
+
+        // Check if this is a path alias
+        const resolvedAlias = resolveTsPathAlias(requirePath, tsConfig, configDir)
+        if (resolvedAlias) {
+          resolvedPath = resolvedAlias
+        } else if (requirePath.startsWith('.')) {
+          resolvedPath = path.resolve(fileBaseDir, requirePath)
+        } else {
+          return match
+        }
+
+        // Handle .js extension that might be .ts
+        if (resolvedPath.endsWith('.js')) {
+          const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
+          if (transpiledFiles.has(tsVersion)) {
+            const tempFile = transpiledFiles.get(tsVersion)
+            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+            const finalPath = relPath.startsWith('.') ? relPath : './' + relPath
+            return `require('${finalPath}')`
+          }
+          return match
+        }
+
+        // Try with .ts extension
+        const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
+
+        // If we transpiled this file, use the temp file
+        if (transpiledFiles.has(tsPath)) {
+          const tempFile = transpiledFiles.get(tsPath)
+          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+          const finalPath = relPath.startsWith('.') ? relPath : './' + relPath
+          return `require('${finalPath}')`
+        }
+
+        // Otherwise, keep the require as-is
         return match
       }
     )
@@ -234,10 +396,13 @@ const __dirname = __dirname_fn(__filename);
   // Get the main transpiled file
   const tempJsFile = transpiledFiles.get(mainFilePath)
 
-  // Store all temp files for cleanup
+  // Convert to file:// URL for dynamic import() (required on Windows)
+  const tempFileUrl = pathToFileURL(tempJsFile).href
+
+  // Store all temp files for cleanup (keep as paths, not URLs)
   const allTempFiles = Array.from(transpiledFiles.values())
 
-  return { tempFile: tempJsFile, allTempFiles, fileMapping: transpiledFiles }
+  return { tempFile: tempFileUrl, allTempFiles, fileMapping: transpiledFiles }
 }
 
 /**

package/lib/utils.js

@@ -7,6 +7,7 @@ import getFunctionArguments from 'fn-args'
 import deepClone from 'lodash.clonedeep'
 import merge from 'lodash.merge'
 import { convertColorToRGBA, isColorProperty } from './colorUtils.js'
+import store from './store.js'
 import Fuse from 'fuse.js'
 import crypto from 'crypto'
 import jsBeautify from 'js-beautify'
@@ -150,6 +151,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
@@ -317,13 +336,13 @@ export const screenshotOutputFolder = function (fileName) {
   const fileSep = path.sep
 
   if (!fileName.includes(fileSep) || fileName.includes('record_')) {
-    return path.resolve(global.output_dir, fileName)
+    return path.resolve(store.outputDir, fileName)
   }
-  return path.resolve(global.codecept_dir, fileName)
+  return path.resolve(store.codeceptDir, fileName)
 }
 
 export const relativeDir = function (fileName) {
-  return fileName.replace(global.codecept_dir, '').replace(/^\//, '')
+  return fileName.replace(store.codeceptDir, '').replace(/^\//, '')
 }
 
 export const beautify = function (code) {
@@ -598,6 +617,12 @@ function createCircularSafeReplacer(keysToSkip = []) {
       return undefined
     }
 
+    // Coerce types that JSON.stringify can't handle natively
+    if (typeof value === 'function') return `[Function: ${value.name || 'anonymous'}]`
+    if (typeof value === 'bigint') return `${value.toString()}n`
+    if (typeof value === 'symbol') return value.toString()
+    if (value instanceof Error) return { name: value.name, message: value.message, stack: value.stack }
+
     if (value === null || typeof value !== 'object') {
       return value
     }
@@ -628,6 +653,25 @@ export const safeStringify = function (obj, keysToSkip = [], space = 0) {
   }
 }
 
+/**
+ * Truncate a string at a byte cap, returning structured info.
+ * @param {string} str
+ * @param {number} maxBytes
+ * @returns {{ value: string, truncated: boolean, fullLength: number }}
+ */
+export const truncateString = function (str, maxBytes) {
+  if (typeof str !== 'string') str = String(str)
+  if (str.length <= maxBytes) {
+    return { value: str, truncated: false, fullLength: str.length }
+  }
+  const dropped = str.length - maxBytes
+  return {
+    value: `${str.slice(0, maxBytes)}\n...[truncated ${dropped} more chars]`,
+    truncated: true,
+    fullLength: str.length,
+  }
+}
+
 export const serializeError = function (error) {
   if (error) {
     const { stack, uncaught, message, actual, expected } = error
@@ -640,6 +684,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

@@ -20,6 +20,7 @@ import event from './event.js'
 import { deserializeTest } from './mocha/test.js'
 import { deserializeSuite } from './mocha/suite.js'
 import recorder from './recorder.js'
+import store from './store.js'
 import runHook from './hooks.js'
 import WorkerStorage from './workerStorage.js'
 import { createRuns } from './command/run-multiple/collection.js'
@@ -28,7 +29,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()
 
@@ -117,11 +118,9 @@ const createWorkerObjects = (testGroups, config, testRoot, options, selectedRuns
   const workersToExecute = []
 
   const currentOutputFolder = config.output
-  let currentMochawesomeReportDir
   let currentMochaJunitReporterFile
 
   if (config.mocha && config.mocha.reporterOptions) {
-    currentMochawesomeReportDir = config.mocha.reporterOptions?.mochawesome.options.reportDir
     currentMochaJunitReporterFile = config.mocha.reporterOptions['mocha-junit-reporter'].options.mochaFile
   }
 
@@ -131,8 +130,6 @@ const createWorkerObjects = (testGroups, config, testRoot, options, selectedRuns
     let workerName = worker.name.replace(':', '_')
     _config.output = `${currentOutputFolder}${separator}${workerName}`
     if (config.mocha && config.mocha.reporterOptions) {
-      _config.mocha.reporterOptions.mochawesome.options.reportDir = `${currentMochawesomeReportDir}${separator}${workerName}`
-
       const _tempArray = currentMochaJunitReporterFile.split(separator)
       _tempArray.splice(
         _tempArray.findIndex(item => item.includes('.xml')),
@@ -224,7 +221,8 @@ class WorkerObject {
     const oldConfig = JSON.parse(this.options.override || '{}')
 
     // Remove customLocatorStrategies from both old and new config before JSON serialization
-    // since functions cannot be serialized and will be lost, causing workers to have empty strategies
+    // since functions cannot be serialized and will be lost, causing workers to have empty strategies.
+    // Note: Only WebDriver helper supports customLocatorStrategies
     const configWithoutFunctions = { ...config }
 
     // Clean both old and new config
@@ -503,6 +501,7 @@ class Workers extends EventEmitter {
     await this._ensureInitialized()
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
+    store.workerMode = true
     process.env.RUNS_WITH_WORKERS = 'true'
 
     // Create workers and set up message handlers immediately (not in recorder queue)
@@ -518,22 +517,8 @@ class Workers extends EventEmitter {
       // Workers are already running, this is just a placeholder step
     })
 
-    // Add overall timeout to prevent infinite hanging
-    const overallTimeout = setTimeout(() => {
-      console.error('[Main] Overall timeout reached (10 minutes). Force terminating remaining workers...')
-      workerThreads.forEach(w => {
-        try {
-          w.terminate()
-        } catch (e) {
-          // ignore
-        }
-      })
-      this._finishRun()
-    }, 600000) // 10 minutes
-
     return new Promise(resolve => {
       this.on('end', () => {
-        clearTimeout(overallTimeout)
         resolve()
       })
     })
@@ -558,11 +543,12 @@ class Workers extends EventEmitter {
     if (this.isPoolMode) {
       this.activeWorkers.set(worker, { available: true, workerIndex: null })
     }
-    
+
     // Track last activity time to detect hanging workers
     let lastActivity = Date.now()
     let currentTest = null
-    const workerTimeout = 300000 // 5 minutes
+    let autoTerminated = false
+    const workerTimeout = process.env.CODECEPT_WORKER_TIMEOUT ? ms(process.env.CODECEPT_WORKER_TIMEOUT) : ms('5m')
     
     const timeoutChecker = setInterval(() => {
       const elapsed = Date.now() - lastActivity
@@ -582,11 +568,6 @@ class Workers extends EventEmitter {
       // Track current test
       if (message.event === event.test.started && message.data) {
         currentTest = message.data.title || message.data.fullTitle
-        console.log(`[Worker ${message.workerIndex}] Started: ${currentTest}`)
-      }
-      
-      if (message.event === event.test.finished && message.data) {
-        console.log(`[Worker ${message.workerIndex}] Finished: ${message.data.title || currentTest}`)
       }
       
       output.process(message.workerIndex)
@@ -627,15 +608,41 @@ class Workers extends EventEmitter {
             })
           }
 
+          const exitTimeout = parseInt(process.env.CODECEPT_AUTO_EXIT_TIMEOUT, 10)
+          if (exitTimeout === 0) break
+          setTimeout(() => {
+            autoTerminated = true
+            worker.terminate()
+          }, exitTimeout || 2000)
+
           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
@@ -649,7 +656,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
@@ -678,28 +689,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
       }
     })
@@ -715,8 +745,8 @@ class Workers extends EventEmitter {
     worker.on('exit', (code) => {
       clearInterval(timeoutChecker)
       this.closedWorkers += 1
-      
-      if (code !== 0) {
+
+      if (code !== 0 && !autoTerminated) {
         console.error(`[Main] Worker exited with code ${code}`)
         if (currentTest) {
           console.error(`[Main] Last test running: ${currentTest}`)
@@ -724,8 +754,6 @@ class Workers extends EventEmitter {
         // Mark as failed
         process.exitCode = 1
       }
-      
-      console.log(`[Main] Workers closed: ${this.closedWorkers}/${this.numberOfWorkers}`)
 
       if (this.isPoolMode) {
         // Pool mode: finish when all workers have exited and no more tests
@@ -740,7 +768,6 @@ class Workers extends EventEmitter {
   }
 
   _finishRun() {
-    console.log('[Main] Finishing test run...')
     event.dispatcher.emit(event.workers.after, { tests: this.workers.map(worker => worker.tests) })
     if (Container.result().hasFailed || this.errors.length > 0) {
       process.exitCode = 1
@@ -782,10 +809,8 @@ class Workers extends EventEmitter {
       this._testStates.clear()
     }
 
-    console.log('[Main] Emitting final results...')
     this.emit(event.all.result, Container.result())
     event.dispatcher.emit(event.workers.result, Container.result())
-    console.log('[Main] Emitting end event...')
     this.emit('end') // internal event
   }