added more fixes

Author: DavertMik

lib/command/workers/runTests.js

@@ -115,50 +115,97 @@ const config = deepMerge(getConfig(options.config || testRoot), overrideConfigs)
 
 function initializeListeners() {
   // suite
-  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: suite.simplify() }))
-  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.before, suite => safelySendToParent({ event: event.suite.before, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.after, suite => safelySendToParent({ event: event.suite.after, workerIndex, data: suite.simplify() }))
 
   // calculate duration
   event.dispatcher.on(event.test.started, test => (test.start = new Date()))
 
   // tests
-  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: test.simplify() }))
-  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.before, test => safelySendToParent({ event: event.test.before, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.after, test => safelySendToParent({ event: event.test.after, workerIndex, data: test.simplify() }))
   // we should force-send correct errors to prevent race condition
-  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: { ...test.simplify(), err } }))
-  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: { ...test.simplify(), err } }))
-  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
-  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: test.simplify() }))
-  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.finished, (test, err) => {
+    const simplifiedData = test.simplify()
+    const serializableErr = serializeError(err)
+    safelySendToParent({ event: event.test.finished, workerIndex, data: { ...simplifiedData, err: serializableErr } })
+  })
+  event.dispatcher.on(event.test.failed, (test, err) => {
+    const simplifiedData = test.simplify()
+    const serializableErr = serializeError(err)
+    safelySendToParent({ event: event.test.failed, workerIndex, data: { ...simplifiedData, err: serializableErr } })
+  })
+  event.dispatcher.on(event.test.passed, (test, err) => safelySendToParent({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.started, test => safelySendToParent({ event: event.test.started, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.skipped, test => safelySendToParent({ event: event.test.skipped, workerIndex, data: test.simplify() }))
 
   // steps
-  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: step.simplify() }))
-  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: step.simplify() }))
-  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: step.simplify() }))
-  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.finished, step => safelySendToParent({ event: event.step.finished, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.started, step => safelySendToParent({ event: event.step.started, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.passed, step => safelySendToParent({ event: event.step.passed, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.failed, step => safelySendToParent({ event: event.step.failed, workerIndex, data: step.simplify() }))
+
+  event.dispatcher.on(event.hook.failed, (hook, err) => {
+    const serializableErr = serializeError(err)
+    safelySendToParent({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err: serializableErr } })
+  })
+  event.dispatcher.on(event.hook.passed, hook => safelySendToParent({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
+  event.dispatcher.on(event.hook.finished, hook => safelySendToParent({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
+
+  event.dispatcher.once(event.all.after, () => safelySendToParent({ event: event.all.after, workerIndex, data: container.result().simplify() }))
+  // all
+  event.dispatcher.once(event.all.result, () => {
+    safelySendToParent({ event: event.all.result, workerIndex, data: container.result().simplify() })
+    parentPort?.close()
+  })
+}
 
-  event.dispatcher.on(event.hook.failed, (hook, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err } }))
-  event.dispatcher.on(event.hook.passed, hook => sendToParentThread({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
-  event.dispatcher.on(event.hook.finished, hook => sendToParentThread({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
+function disablePause() {
+  global.pause = () => {}
+}
 
-  if (!poolMode) {
-    // In regular mode, close worker after all tests are complete
-    event.dispatcher.once(event.all.after, () => {
-      sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
-    })
-    // all
-    event.dispatcher.once(event.all.result, () => {
-      sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
-      parentPort?.close()
-    })
-  } else {
-    // In pool mode, don't send result events for individual tests
-    // Results will be sent once when the worker completes all tests
+function serializeError(err) {
+  if (!err) return null
+  try {
+    return {
+      message: err.message,
+      stack: err.stack,
+      name: err.name,
+      actual: err.actual,
+      expected: err.expected,
+    }
+  } catch {
+    return { message: 'Error could not be serialized', name: 'Error' }
   }
 }
 
-function disablePause() {
-  global.pause = () => {}
+function safelySendToParent(data) {
+  try {
+    parentPort?.postMessage(data)
+  } catch (cloneError) {
+    // Fallback for non-serializable data
+    const fallbackData = { ...data }
+
+    // Try to serialize error objects if present
+    if (fallbackData.data && fallbackData.data.err) {
+      fallbackData.data.err = serializeError(fallbackData.data.err)
+    }
+
+    // If still fails, send minimal data
+    try {
+      parentPort?.postMessage(fallbackData)
+    } catch (finalError) {
+      parentPort?.postMessage({
+        event: data.event,
+        workerIndex,
+        data: {
+          title: fallbackData.data?.title || 'Unknown',
+          state: fallbackData.data?.state || 'error',
+          err: { message: 'Data could not be serialized' },
+        },
+      })
+    }
+  }
 }
 
 function sendToParentThread(data) {

lib/helper/WebDriver.js

@@ -2,6 +2,7 @@ let webdriverio
 
 import assert from 'assert'
 import path from 'path'
+import crypto from 'crypto'
 import Helper from '@codeceptjs/helper'
 import promiseRetry from 'promise-retry'
 import { includes as stringIncludes } from '../assert/include.js'
@@ -2626,7 +2627,6 @@ class WebDriver extends Helper {
    */
   async openNewTab(url = 'about:blank', windowName = null) {
     const client = this.browser
-    const crypto = require('crypto')
     if (windowName == null) {
       windowName = crypto.randomBytes(32).toString('hex')
     }

lib/index.js

@@ -22,6 +22,7 @@ import locator from './locator.js'
 import heal from './heal.js'
 import ai from './ai.js'
 import Workers from './workers.js'
+import Secret, { secret } from './secret.js'
 
 export default {
   /** @type {typeof CodeceptJS.Codecept} */
@@ -61,25 +62,12 @@ export default {
   ai,
 
   Workers,
+
+  /** @type {typeof CodeceptJS.Secret} */
+  Secret,
+  /** @type {typeof CodeceptJS.secret} */
+  secret,
 }
 
 // Named exports for ESM compatibility
-export {
-  codecept,
-  output,
-  container,
-  event,
-  recorder,
-  config,
-  actor,
-  helper,
-  pause,
-  within,
-  dataTable,
-  dataTableArgument,
-  store,
-  locator,
-  heal,
-  ai,
-  Workers
-}
+export { codecept, output, container, event, recorder, config, actor, helper, pause, within, dataTable, dataTableArgument, store, locator, heal, ai, Workers, Secret, secret }

test/acceptance/session_test.js

@@ -137,7 +137,7 @@ Scenario('should work with within @Puppeteer @Playwright', ({ I }) => {
     I.seeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' })
     I.dontSeeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' })
   })
-})
+}).retry(2)
 
 Scenario('change page emulation @Playwright', async ({ I }) => {
   I.amOnPage('/')

test/docker-compose.yml

@@ -2,7 +2,7 @@ services:
   test-rest:
     <<: &test-service
       build: ..
-      entrypoint: ['']
+      entrypoint: npx mocha
       working_dir: /codecept
       env_file: .env
       volumes: