codeceptjs 4.2.0-beta.4 → 4.2.1-beta.1

package/lib/workers.js

@@ -20,9 +20,11 @@ import output from './output.js'
 import event from './event.js'
 import { deserializeTest } from './mocha/test.js'
 import { deserializeSuite } from './mocha/suite.js'
+import Step from './step/base.js'
 import recorder from './recorder.js'
 import store from './store.js'
 import runHook from './hooks.js'
+import WebServer from './webServer.js'
 import WorkerStorage from './workerStorage.js'
 import { createRuns } from './command/run-multiple/collection.js'
 
@@ -57,11 +59,23 @@ const populateGroups = numberOfWorkers => {
   return groups
 }
 
-const createWorker = (workerObject, isPoolMode = false) => {
+const matchesGrep = (mocha, test) => {
+  const { grep, invert } = mocha.options
+  if (!grep) return true
+  return grep.test(test.fullTitle()) !== Boolean(invert)
+}
+
+const withoutEmptyGroups = groups => {
+  const nonEmpty = groups.filter(group => group.length)
+  return nonEmpty.length ? nonEmpty : groups.slice(0, 1)
+}
+
+const createWorker = (workerObject, isPoolMode = false, skipTests = []) => {
   const worker = new Worker(pathToWorker, {
     workerData: {
       options: simplifyObject(workerObject.options),
       tests: workerObject.tests,
+      skipTests,
       testRoot: workerObject.testRoot,
       workerIndex: workerObject.workerIndex + 1,
       poolMode: isPoolMode,
@@ -104,6 +118,8 @@ const simplifyObject = object => {
     }, {})
 }
 
+const deserializeStep = data => Object.assign(new Step(data.title), data)
+
 const createWorkerObjects = (testGroups, config, testRoot, options, selectedRuns) => {
   selectedRuns = options && options.all && config.multiple ? Object.keys(config.multiple) : selectedRuns
   if (selectedRuns === undefined || !selectedRuns.length || config.multiple === undefined) {
@@ -213,6 +229,7 @@ class WorkerObject {
    */
   constructor(workerIndex) {
     this.workerIndex = workerIndex
+    this.serial = false
     this.options = {}
     this.tests = []
     this.testRoot = getTestRoot()
@@ -288,6 +305,7 @@ class Workers extends EventEmitter {
     this.testGroups = []
     this.testPool = []
     this.testPoolInitialized = false
+    this.serialTests = []
     this.isPoolMode = config.by === 'pool'
     this.activeWorkers = new Map()
     this.maxWorkers = numberOfWorkers // Track original worker count for pool mode
@@ -312,9 +330,21 @@ class Workers extends EventEmitter {
 
   async _initWorkers(numberOfWorkers, config) {
     await this.splitTestsByGroups(numberOfWorkers, config)
+    this.serialTests = await this.createGroupOfSerialTests()
+    if (this.serialTests.length && !this.isPoolMode) {
+      this.testGroups = this.testGroups.map(group => group.filter(uid => !this.serialTests.includes(uid))).filter(group => group.length)
+    }
     // For function-based grouping, use the actual number of test groups created
     const actualNumberOfWorkers = isFunction(config.by) ? this.testGroups.length : numberOfWorkers
     this.workers = createWorkerObjects(this.testGroups, this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
+    if (this.serialTests.length) {
+      const serialWorkers = createWorkerObjects([this.serialTests], this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
+      for (const worker of serialWorkers) {
+        worker.workerIndex = this.workers.length
+        worker.serial = true
+        this.workers.push(worker)
+      }
+    }
     this.numberOfWorkers = this.workers.length
   }
 
@@ -345,7 +375,8 @@ class Workers extends EventEmitter {
       if (config.by === 'pool') {
         this.createTestPool(numberOfWorkers)
       } else {
-        this.testGroups = config.by === 'suite' ? await this.createGroupsOfSuites(numberOfWorkers) : await this.createGroupsOfTests(numberOfWorkers)
+        const groups = config.by === 'suite' ? await this.createGroupsOfSuites(numberOfWorkers) : await this.createGroupsOfTests(numberOfWorkers)
+        this.testGroups = withoutEmptyGroups(groups)
       }
     }
   }
@@ -375,17 +406,21 @@ class Workers extends EventEmitter {
     const mocha = Container.mocha()
     mocha.files = files
     await loadTests(mocha)
+    this.codecept.filterLastFailedTests(mocha)
 
     const groups = populateGroups(numberOfWorkers)
     let groupCounter = 0
 
+    const tests = []
     mocha.suite.eachTest(test => {
-      const i = groupCounter % groups.length
-      if (test) {
-        groups[i].push(test.uid)
-        groupCounter++
-      }
+      if (test) tests.push(test)
     })
+    const selected = tests.filter(test => matchesGrep(mocha, test))
+
+    for (const test of selected.length ? selected : tests) {
+      groups[groupCounter % groups.length].push(test.uid)
+      groupCounter++
+    }
     
     // Clean up after collecting test UIDs
     mocha.unloadFiles()
@@ -393,6 +428,32 @@ class Workers extends EventEmitter {
     return groups
   }
 
+  /**
+   * Collects tests matching `--serial` option or `serial` config pattern.
+   * These tests are excluded from parallel workers and run one by one after them.
+   *
+   * @returns {Promise<string[]>}
+   */
+  async createGroupOfSerialTests() {
+    const pattern = this.options.serial || this.codecept?.config.serial
+    if (!pattern) return []
+    const serial = new RegExp(pattern)
+
+    Container.createMocha(this.codecept.config.mocha || {}, this.options)
+    const mocha = Container.mocha()
+    mocha.files = this.codecept.testFiles
+    await loadTests(mocha, { reload: true })
+
+    const group = []
+    mocha.suite.eachTest(test => {
+      if (test && serial.test(test.fullTitle()) && matchesGrep(mocha, test)) group.push(test.uid)
+    })
+
+    mocha.unloadFiles()
+
+    return group
+  }
+
   /**
    * @param {Number} numberOfWorkers
    */
@@ -463,15 +524,15 @@ class Workers extends EventEmitter {
     const mocha = Container.mocha()
     mocha.files = files
     await loadTests(mocha)
+    this.codecept.filterLastFailedTests(mocha)
     
-    mocha.suite.suites.forEach(suite => {
+    const suites = mocha.suite.suites.map(suite => suite.tests.filter(test => test))
+    const selected = suites.map(tests => tests.filter(test => matchesGrep(mocha, test))).filter(tests => tests.length)
+
+    for (const tests of selected.length ? selected : suites) {
       const i = indexOfSmallestElement(groups)
-      suite.tests.forEach(test => {
-        if (test) {
-          groups[i].push(test.uid)
-        }
-      })
-    })
+      tests.forEach(test => groups[i].push(test.uid))
+    }
     
     // Clean up after collecting test UIDs
     mocha.unloadFiles()
@@ -490,12 +551,17 @@ class Workers extends EventEmitter {
 
   async bootstrapAll() {
     await this._ensureInitialized()
+    await WebServer.startAll(this.codecept.config.webServer)
     return runHook(this.codecept.config.bootstrapAll, 'bootstrapAll')
   }
 
   async teardownAll() {
     await this._ensureInitialized()
-    return runHook(this.codecept.config.teardownAll, 'teardownAll')
+    try {
+      return await runHook(this.codecept.config.teardownAll, 'teardownAll')
+    } finally {
+      await WebServer.stopAll()
+    }
   }
 
   async run() {
@@ -520,7 +586,8 @@ class Workers extends EventEmitter {
       : 0
 
     for (const worker of this.workers) {
-      const workerThread = createWorker(worker, this.isPoolMode)
+      if (worker.serial) continue
+      const workerThread = createWorker(worker, this.isPoolMode, this.serialTests)
       this._listenWorkerEvents(workerThread)
       workerThreads.push(workerThread)
       
@@ -531,6 +598,8 @@ class Workers extends EventEmitter {
       }
     }
 
+    if (!workerThreads.length) this._runSerialWorker()
+
     recorder.add('workers started', () => {
       // Workers are already running, this is just a placeholder step
     })
@@ -542,6 +611,14 @@ class Workers extends EventEmitter {
     })
   }
 
+  _runSerialWorker() {
+    const parallelWorkers = this.workers.filter(worker => !worker.serial)
+    if (this.closedWorkers < parallelWorkers.length) return
+    const worker = this.workers[this.closedWorkers]
+    if (!worker) return
+    this._listenWorkerEvents(createWorker(worker))
+  }
+
   /**
    * @returns {Array<WorkerObject>}
    */
@@ -720,20 +797,32 @@ class Workers extends EventEmitter {
           }
           break
         case event.step.finished:
-          this.emit(event.step.finished, message.data)
-          event.dispatcher.emit(event.step.finished, message.data)
+          {
+            const step = deserializeStep(message.data)
+            this.emit(event.step.finished, step)
+            event.dispatcher.emit(event.step.finished, step)
+          }
           break
         case event.step.started:
-          this.emit(event.step.started, message.data)
-          event.dispatcher.emit(event.step.started, message.data)
+          {
+            const step = deserializeStep(message.data)
+            this.emit(event.step.started, step)
+            event.dispatcher.emit(event.step.started, step)
+          }
           break
         case event.step.passed:
-          this.emit(event.step.passed, message.data)
-          event.dispatcher.emit(event.step.passed, message.data)
+          {
+            const step = deserializeStep(message.data)
+            this.emit(event.step.passed, step)
+            event.dispatcher.emit(event.step.passed, step)
+          }
           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)
+          {
+            const step = deserializeStep(message.data)
+            this.emit(event.step.failed, step, step.error)
+            event.dispatcher.emit(event.step.failed, step, step.error)
+          }
           break
         case event.hook.failed:
           // Hook failures are already reported as test failures by the worker
@@ -773,14 +862,10 @@ class Workers extends EventEmitter {
         process.exitCode = 1
       }
 
-      if (this.isPoolMode) {
-        // Pool mode: finish when all workers have exited and no more tests
-        if (this.closedWorkers === this.numberOfWorkers) {
-          this._finishRun()
-        }
-      } else if (this.closedWorkers === this.numberOfWorkers) {
-        // Regular mode: finish when all original workers have exited
+      if (this.closedWorkers === this.numberOfWorkers) {
         this._finishRun()
+      } else {
+        this._runSerialWorker()
       }
     })
   }
@@ -802,6 +887,7 @@ class Workers extends EventEmitter {
         // For tests with retries configured, emit all failures + final success
         // For tests without retries, emit only final state
         const lastState = states[states.length - 1]
+        Container.result().addTest(deserializeTest(lastState.data))
 
         // Check if this test had retries by looking for failure followed by success
         const hasRetryPattern = states.length > 1 && states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
@@ -829,6 +915,7 @@ class Workers extends EventEmitter {
 
     this.emit(event.all.result, Container.result())
     event.dispatcher.emit(event.workers.result, Container.result())
+    if (Container.result().tests.length) Container.result().save()
     this.emit('end') // internal event
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.2.0-beta.4",
+  "version": "4.2.1-beta.1",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
@@ -80,6 +80,7 @@
     "test:unit:webbapi:webDriver:noSeleniumServer": "mocha test/helper/WebDriver.noSeleniumServer_test.js --timeout 10000 --reporter @testomatio/reporter/mocha",
     "test:unit:webbapi:cdpbrowser": "mocha test/helper/CDPBrowser_chrome_test.js --timeout 30000 --reporter @testomatio/reporter/mocha",
     "test:unit:webbapi:obscura": "mocha test/helper/CDPBrowser_obscura_test.js --timeout 30000 --reporter @testomatio/reporter/mocha",
+    "test:unit:webbapi:lightpanda": "mocha test/helper/CDPBrowser_lightpanda_test.js --timeout 30000 --reporter @testomatio/reporter/mocha",
     "test:unit:expect": "mocha test/helper/Expect_test.js --reporter @testomatio/reporter/mocha",
     "test:plugin": "mocha test/plugin/plugin_test.js --reporter @testomatio/reporter/mocha",
     "def": "./runok.cjs def",
@@ -101,7 +102,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@xmldom/xmldom": "0.9.10",
     "acorn": "8.15.0",
-    "ai": "^6.0.43",
+    "ai": "7.0.132",
     "arrify": "3.0.0",
     "axios": "1.16.1",
     "chalk": "4.1.2",
@@ -149,6 +150,7 @@
     "@eslint/js": "9.39.2",
     "@faker-js/faker": "10.3.0",
     "@inquirer/testing": "^3.0.3",
+    "@openrouter/ai-sdk-provider": "^3.1.0",
     "@pollyjs/adapter-puppeteer": "6.0.6",
     "@pollyjs/core": "6.0.6",
     "@testomatio/reporter": "^2.3.1",

package/typings/index.d.ts

@@ -81,6 +81,21 @@ declare namespace CodeceptJS {
     }
   }
 
+  type WebServerConfig = {
+    /** Shell command that starts the application, e.g. `npm run start` */
+    command: string
+    /** URL polled with GET until it responds; any HTTP status counts as ready */
+    url: string
+    /** Set to `false` to skip starting the server. Defaults to `true` */
+    enabled?: boolean
+    /** Milliseconds to wait for `url` to respond. Defaults to `60000` */
+    timeout?: number
+    /** Working directory for the command, relative to the config directory */
+    cwd?: string
+    /** Extra environment variables for the command */
+    env?: Record<string, string>
+  }
+
   type MainConfig = {
     /** Pattern to locate CodeceptJS tests.
      * Allows to enter glob pattern or an Array<string> of patterns to match tests / test file names.
@@ -132,6 +147,15 @@ declare namespace CodeceptJS {
      * ```
      */
     grep?: string
+    /**
+     * Pattern for tests that must not run in parallel.
+     * In `run-workers` matching tests run one by one after all parallel workers finish.
+     *
+     * ```js
+     * serial: '@serial'
+     * ```
+     */
+    serial?: string | RegExp
     /**
      * Enable and configure helpers:
      *
@@ -359,6 +383,17 @@ declare namespace CodeceptJS {
      * [Execute JS code after finishing tests in parallel mode](https://codecept.io/bootstrap/#bootstrapall-teardownall)
      */
     teardownAll?: (() => Promise<void>) | boolean | string
+    /**
+     * [Start the application under test](https://codecept.io/configuration/#web-server) before tests run and stop it after.
+     *
+     * ```js
+     * webServer: {
+     *   command: 'npm run start',
+     *   url: 'http://localhost:3000',
+     * }
+     * ```
+     */
+    webServer?: WebServerConfig | WebServerConfig[]
 
     /** Enable [localized test commands](https://codecept.io/translation/) */
     translation?: string
@@ -433,7 +468,12 @@ declare namespace CodeceptJS {
   // Could get extended by user generated typings
   interface Methods extends ActorStatic {}
   interface I {}
-  interface IHook {}
+  interface IHook {
+    (callback: HookCallback): HookConfig
+  }
+  interface IHookSuite {
+    (callback: HookSuiteCallback): HookConfig
+  }
   interface IScenario {}
   interface IFeature {
     (title: string, opts?: { [key: string]: any }): FeatureConfig
@@ -473,8 +513,22 @@ declare namespace CodeceptJS {
 
   type StringOrSecret = string | CodeceptJS.Secret
 
+  interface GherkinCallback {
+    (test: Test): void | Promise<void>
+  }
+  interface GherkinEventEmitter {}
+  interface GherkinHook {
+    (callback: GherkinCallback): GherkinEventEmitter
+  }
   interface HookCallback {
-    (args: SupportObject): void | Promise<void>
+    // `suite` has type Mocha.Suite if hook (Background/Before/After) is called before `Feature()`
+    // `suite` has type CodeceptJS.Suite if hook is called after `Feature()`
+    (args: SupportObject & { suite: Mocha.Suite; test: Test }): void | Promise<void>
+  }
+  interface HookSuiteCallback {
+    // `suite` has type Mocha.Suite if hook (BeforeSuite/AfterSuite) is called before `Feature()`
+    // `suite` has type CodeceptJS.Suite if hook is called after `Feature()`
+    (args: SupportObject & { suite: Mocha.Suite }): void | Promise<void>
   }
   interface Scenario extends IScenario {
     only: IScenario
@@ -495,9 +549,6 @@ declare namespace CodeceptJS {
     (title: string, callback?: HookCallback): ScenarioConfig
     (title: string, opts: { [key: string]: any }, callback: HookCallback): ScenarioConfig
   }
-  interface IHook {
-    (callback: HookCallback): HookConfig
-  }
 
   interface Globals {
     codeceptjs: typeof codeceptjs
@@ -545,11 +596,13 @@ declare function xData(data: any): CodeceptJS.IData
 declare function DefineParameterType(options: CodeceptJS.IParameterTypeDefinition<any>): void
 
 // Hooks
-declare const BeforeSuite: CodeceptJS.IHook
-declare const AfterSuite: CodeceptJS.IHook
+declare const BeforeSuite: CodeceptJS.IHookSuite
+declare const AfterSuite: CodeceptJS.IHookSuite
 declare const Background: CodeceptJS.IHook
 declare const Before: CodeceptJS.IHook
 declare const After: CodeceptJS.IHook
+declare const GherkinBefore: CodeceptJS.GherkinHook
+declare const GherkinAfter: CodeceptJS.GherkinHook
 
 // Plugins
 declare const __: any