Test rerun test suite/case state fix

Author: vishnuv688

example/wdio.conf.ts

@@ -63,7 +63,7 @@ export const config: Options.Testrunner = {
   capabilities: [
     {
       browserName: 'chrome',
-      browserVersion: '146.0.7680.72', // specify chromium browser version for testing
+      browserVersion: '146.0.7680.178', // specify chromium browser version for testing
       'goog:chromeOptions': {
         args: [
           '--headless',

packages/app/src/controller/DataManager.ts

@@ -19,6 +19,7 @@ import {
 } from './context.js'
 import { CACHE_ID } from './constants.js'
 import { getTimestamp } from '../utils/helpers.js'
+import { rerunState } from './rerunState.js'
 import type {
   TestStatsFragment,
   SuiteStatsFragment,
@@ -87,16 +88,30 @@ export class DataManagerController implements ReactiveController {
   }
 
   clearExecutionData(uid?: string, entryType?: 'suite' | 'test') {
-    this.#resetExecutionData()
+    // If we are already tracking a feature-level rerun and this clear is for
+    // a child scenario (not the top-level rerun trigger itself), skip resetting
+    // execution data so previously-completed scenarios' data is preserved.
+    const isChildOfActiveRerun = !!(uid && rerunState.activeRerunSuiteUid && uid !== rerunState.activeRerunSuiteUid)
+
+    if (!isChildOfActiveRerun) {
+      this.#resetExecutionData()
+    }
 
     // When the backend sends clearExecutionData with no uid (e.g. a full Nightwatch
     // rerun), immediately mark all suites as running so the spinner shows instead
     // of the previous run's terminal state (passed/failed).
     if (!uid) {
+      rerunState.activeRerunSuiteUid = undefined
       this.#markTestAsRunning('*', 'suite')
       return
     }
 
+    // Track the top-level rerun suite uid so we can identify child-scenario
+    // clears (from the Nightwatch backend) and skip their data wipes.
+    if (!isChildOfActiveRerun && entryType === 'suite' && uid !== '*') {
+      rerunState.activeRerunSuiteUid = uid
+    }
+
     // Track explicit single-test reruns so merge logic can keep sibling tests
     // stable while the backend emits suite-level "pending" snapshots.
     if (entryType === 'test' && uid !== '*') {
@@ -221,8 +236,12 @@ export class DataManagerController implements ReactiveController {
                 ...(matched
                   ? {
                       state: 'running' as const,
-                      start: runStart,
-                      end: undefined
+                      // Don't reset the parent's start/end when it is already
+                      // running — subsequent child-scenario marks would otherwise
+                      // reset the feature's original run timestamp.
+                      ...(s.state !== 'running'
+                        ? { start: runStart, end: undefined }
+                        : {})
                     }
                   : {}),
                 tests: updatedTests || [],
@@ -329,6 +348,33 @@ export class DataManagerController implements ReactiveController {
   }
 
   #shouldResetForNewRun(data: unknown): boolean {
+    // During a UI-triggered rerun, suppress auto-detection so sibling-scenario
+    // updates don't wipe accumulated execution data.
+    // Still update #lastSeenRunTimestamp so that once activeRerunSuiteUid is
+    // cleared the final suite update isn't mistakenly treated as a new run.
+    if (rerunState.activeRerunSuiteUid) {
+      const payloads = Array.isArray(data)
+        ? (data as Record<string, SuiteStatsFragment>[])
+        : ([data] as Record<string, SuiteStatsFragment>[])
+      for (const chunk of payloads) {
+        if (!chunk) {
+          continue
+        }
+        for (const suite of Object.values(chunk)) {
+          if (!suite?.start) {
+            continue
+          }
+          const t = getTimestamp(
+            suite.start as Date | number | string | undefined
+          )
+          if (t > this.#lastSeenRunTimestamp) {
+            this.#lastSeenRunTimestamp = t
+          }
+        }
+      }
+      return false
+    }
+
     const payloads = Array.isArray(data)
       ? (data as Record<string, SuiteStatsFragment>[])
       : ([data] as Record<string, SuiteStatsFragment>[])
@@ -399,6 +445,7 @@ export class DataManagerController implements ReactiveController {
 
   #handleTestStopped() {
     this.#activeRerunTestUid = undefined
+    rerunState.activeRerunSuiteUid = undefined
 
     // Mark all running tests as failed when test execution is stopped
     const suites = this.suitesContextProvider.value || []
@@ -563,6 +610,15 @@ export class DataManagerController implements ReactiveController {
     this.suitesContextProvider.setValue(
       Array.from(suiteMap.entries()).map(([uid, suite]) => ({ [uid]: suite }))
     )
+
+    // Once the active rerun suite reaches a terminal state, clear the tracking
+    // flag so subsequent CLI-triggered runs can be detected normally.
+    if (rerunState.activeRerunSuiteUid) {
+      const activeSuite = suiteMap.get(rerunState.activeRerunSuiteUid)
+      if (activeSuite?.end) {
+        rerunState.activeRerunSuiteUid = undefined
+      }
+    }
   }
 
   #handleLogsUpdate(data: string[]) {
@@ -649,8 +705,14 @@ export class DataManagerController implements ReactiveController {
     // #mergeChildSuites preserves stale child suites from the previous run,
     // but they must not keep their terminal states — mark them 'pending' so
     // they render as a spinner instead of a stale checkmark/cross.
+    // Exception: when only a specific child scenario is being rerun
+    // (activeRerunSuiteUid differs from the incoming feature suite's uid),
+    // sibling scenarios must keep their existing terminal states.
+    const isChildRerun =
+      !!rerunState.activeRerunSuiteUid &&
+      rerunState.activeRerunSuiteUid !== incoming.uid
     const finalSuites =
-      incoming.state === 'pending' && mergedSuites
+      incoming.state === 'pending' && mergedSuites && !isChildRerun
         ? mergedSuites.map((s) =>
             s.state === 'passed' || s.state === 'failed'
               ? { ...s, state: 'pending' as const, end: undefined }

packages/app/src/controller/context.ts

@@ -27,3 +27,6 @@ export const suiteContext = createContext<Record<string, SuiteStatsFragment>[]>(
 export const hasConnectionContext = createContext<boolean>(
   Symbol('hasConnection')
 )
+export const activeRerunContext = createContext<string | undefined>(
+  Symbol('activeRerunContext')
+)

packages/app/src/controller/rerunState.ts

@@ -0,0 +1,4 @@
+export const rerunState = {
+  activeRerunSuiteUid: undefined as string | undefined,
+  isTopLevelRerun: false
+}

packages/nightwatch-devtools/package.json

@@ -24,6 +24,7 @@
   "license": "MIT",
   "dependencies": {
     "@wdio/devtools-backend": "workspace:*",
+    "@wdio/devtools-script": "workspace:*",
     "@wdio/logger": "^9.6.0",
     "import-meta-resolve": "^4.2.0",
     "stacktrace-parser": "^0.1.10",

packages/nightwatch-devtools/src/constants.ts

@@ -92,8 +92,8 @@ export const NAVIGATION_COMMANDS = ['url', 'navigate', 'navigateTo'] as const
 /** Spinner progress frames — suppress from UI Console output. */
 export const SPINNER_RE = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/u
 
-/** Matches a path segment that indicates a test/spec directory (e.g. /tests/ or /spec/). */
-export const TEST_PATH_PATTERN = /\/(test|spec|tests)\//i
+/** Matches a path segment that indicates a test/spec directory (e.g. /tests/, /spec/, /nightwatch/examples/, /features/). */
+export const TEST_PATH_PATTERN = /\/(test|spec|tests|nightwatch|examples?|features|step-definitions)\//i
 
 /** Matches file names that follow the *.test.ts / *.spec.js naming convention. */
 export const TEST_FILE_PATTERN = /\.(?:test|spec)\.[cm]?[jt]sx?$/i

packages/nightwatch-devtools/src/helpers/utils.ts

@@ -150,9 +150,20 @@ export function extractTestMetadata(filePath: string): TestFileMetadata {
           result.suiteLine = lineNum
         }
       }
-      const m = line.match(/(?:it|test|specify)\s*\(\s*['"`]([^'"`]+)['"`]/)
-      if (m) {
-        result.testNames.push(m[1])
+      // describe/it style: it('name', ...) / test('name', ...) / specify('name', ...)
+      const itMatch = line.match(/(?:it|test|specify)\s*\(\s*['"`]([^'"`]+)['"`]/)
+      if (itMatch) {
+        result.testNames.push(itMatch[1])
+        result.testLines.push(lineNum)
+        continue
+      }
+      // Object-export style (NightwatchTests): 'Test name': () => { / 'Test name': function() {
+      // This is the default format generated by `npx nightwatch --yes`
+      const objMatch = line.match(
+        /^\s*['"`]([^'"`]+)['"`]\s*:\s*(?:async\s+)?(?:\([^)]*\)\s*=>|function\s*\()/
+      )
+      if (objMatch) {
+        result.testNames.push(objMatch[1])
         result.testLines.push(lineNum)
       }
     }

packages/nightwatch-devtools/src/index.ts

@@ -62,6 +62,7 @@ class NightwatchDevToolsPlugin {
   #failCount = 0
   #skipCount = 0
   #configPath: string | undefined
+  #srcFolders: string[] = []
 
   #getRerunLabel() {
     return process.env.DEVTOOLS_RERUN_ENTRY_TYPE === 'test'
@@ -240,6 +241,13 @@ class NightwatchDevToolsPlugin {
     const desiredCapabilities = browser.desiredCapabilities || {}
     const sessionId = browser.sessionId
     const opts = browser.options || {}
+
+    // Capture src_folders once so beforeEach can resolve test file paths
+    if (this.#srcFolders.length === 0) {
+      const sf = (opts as any).src_folders
+      this.#srcFolders = Array.isArray(sf) ? sf : sf ? [sf] : []
+    }
+
     this.sessionCapturer.sendUpstream('metadata', {
       type: TraceType.Testrunner,
       capabilities,
@@ -418,7 +426,13 @@ class NightwatchDevToolsPlugin {
     const isRetry = existingIdx !== -1
     if (isRetry) {
       featureSuite.suites[existingIdx] = scenarioSuite
-      this.sessionCapturer.sendUpstream('clearExecutionData', {})
+      // Pass the specific scenario uid so only this scenario's execution data
+      // is reset — a uid-less clearExecutionData would mark ALL suites as
+      // running, destroying the previous terminal states of sibling scenarios.
+      this.sessionCapturer.sendUpstream('clearExecutionData', {
+        uid: scenarioUid,
+        entryType: 'suite'
+      })
     } else {
       featureSuite.suites.push(scenarioSuite)
     }
@@ -584,7 +598,29 @@ class NightwatchDevToolsPlugin {
 
     if (!fullPath && testFile) {
       const workspaceRoot = process.cwd()
+      // currentTest.module is the path relative to a src_folder, e.g. "basic/ecosia"
+      // So we must try: path.join(cwd, srcFolder, module + '.js') for each src_folder
+      const modulePath = (currentTest.module || '').replace(/\\/g, '/')
+      const srcFolderPaths = this.#srcFolders.flatMap((sf) =>
+        modulePath
+          ? [
+              path.join(workspaceRoot, sf, modulePath + '.js'),
+              path.join(workspaceRoot, sf, modulePath + '.ts'),
+              path.join(workspaceRoot, sf, modulePath + '.cjs'),
+              path.join(workspaceRoot, sf, modulePath),
+            ]
+          : []
+      )
       const possiblePaths = [
+        // Highest priority: expand module path via each configured src_folder
+        ...srcFolderPaths,
+        // Fallback: treat module path as relative to cwd (works when src_folders isn't nested)
+        ...(modulePath ? [
+          path.join(workspaceRoot, modulePath + '.js'),
+          path.join(workspaceRoot, modulePath + '.ts'),
+          path.join(workspaceRoot, modulePath + '.cjs'),
+          path.join(workspaceRoot, modulePath),
+        ] : []),
         path.join(workspaceRoot, 'example/tests', testFile + '.js'),
         path.join(workspaceRoot, 'example/tests', testFile),
         path.join(workspaceRoot, 'tests', testFile + '.js'),

packages/nightwatch-devtools/src/session.ts

@@ -569,12 +569,17 @@ export class SessionCapturer {
       `
 
       await browser.execute(injectionScript, [scriptContent])
-      await browser.pause(300)
 
-      const checkResult = await browser.execute(
-        'return typeof window.wdioTraceCollector !== "undefined"'
-      )
-      const hasCollector = ((checkResult as any)?.value ?? checkResult) === true
+      // Poll for collector — the async IIFE may take a moment to initialise
+      let hasCollector = false
+      for (let attempt = 0; attempt < 5; attempt++) {
+        await browser.pause(200)
+        const checkResult = await browser.execute(
+          'return typeof window.wdioTraceCollector !== "undefined"'
+        )
+        hasCollector = ((checkResult as any)?.value ?? checkResult) === true
+        if (hasCollector) break
+      }
 
       if (hasCollector) {
         log.info('✓ Script injected and collector ready')