Cucumber testrunner command capture fix

Author: vishnuv688

packages/app/src/controller/DataManager.ts

@@ -49,17 +49,20 @@ export const isTestRunningContext = createContext<boolean>(
 )
 
 interface SocketMessage<
-  T extends keyof TraceLog | 'testStopped' | 'clearExecutionData' =
+  T extends keyof TraceLog | 'testStopped' | 'clearExecutionData' | 'replaceCommand' =
     | keyof TraceLog
     | 'testStopped'
     | 'clearExecutionData'
+    | 'replaceCommand'
 > {
   scope: T
   data: T extends keyof TraceLog
     ? TraceLog[T]
     : T extends 'clearExecutionData'
       ? { uid?: string }
-      : unknown
+      : T extends 'replaceCommand'
+        ? { oldTimestamp: number; command: CommandLog }
+        : unknown
 }
 
 export class DataManagerController implements ReactiveController {
@@ -285,6 +288,14 @@ export class DataManagerController implements ReactiveController {
         return
       }
 
+      // Handle in-place command replacement (retry deduplication)
+      if (scope === 'replaceCommand') {
+        const { oldTimestamp, command } = data as { oldTimestamp: number; command: CommandLog }
+        this.#handleReplaceCommand(oldTimestamp, command)
+        this.#host.requestUpdate()
+        return
+      }
+
       // Check for new run BEFORE processing suites data
       if (scope === 'suites') {
         const shouldReset = this.#shouldResetForNewRun(data)
@@ -338,12 +349,41 @@ export class DataManagerController implements ReactiveController {
             ? suite.start.getTime()
             : typeof suite.start === 'number'
               ? suite.start
-              : 0
+              : typeof suite.start === 'string'
+                ? new Date(suite.start as string).getTime() || 0
+                : 0
+
+        if (suiteStartTime <= 0) {
+          continue
+        }
 
-        // New run detected if we see a newer start timestamp
+        // New run detected if we see a newer start timestamp.
+        // Exception: if the existing suite for this uid has no end time, it is
+        // still an ongoing run (e.g. a Cucumber feature spanning multiple
+        // scenarios) — treat it as a continuation, not a new run.
         if (suiteStartTime > this.#lastSeenRunTimestamp) {
+          const existingChunks = this.suitesContextProvider.value || []
+          let existingEnd: unknown = undefined
+          outer: for (const ec of existingChunks) {
+            for (const [uid, existing] of Object.entries(
+              ec as Record<string, SuiteStatsFragment>
+            )) {
+              if (uid === Object.keys(chunk)[0]) {
+                existingEnd = (existing as any)?.end
+                break outer
+              }
+            }
+          }
+          // Only reset if the previous run was already finished (had an end time).
+          // An ongoing run (end == null / undefined) is just a continuation.
+          const previousRunFinished =
+            existingEnd !== null && existingEnd !== undefined
+          if (previousRunFinished) {
+            this.#lastSeenRunTimestamp = suiteStartTime
+            return true
+          }
+          // Continuation — update tracking timestamp but do NOT reset
           this.#lastSeenRunTimestamp = suiteStartTime
-          return true
         }
       }
     }
@@ -428,6 +468,20 @@ export class DataManagerController implements ReactiveController {
     ])
   }
 
+  #handleReplaceCommand(oldTimestamp: number, newCommand: CommandLog) {
+    const current = this.commandsContextProvider.value || []
+    // Find the last entry with the matching timestamp (most recent retry)
+    const idx = current.map((c) => c.timestamp).lastIndexOf(oldTimestamp)
+    if (idx !== -1) {
+      const updated = [...current]
+      updated[idx] = newCommand
+      this.commandsContextProvider.setValue(updated)
+    } else {
+      // No matching entry found — just append
+      this.commandsContextProvider.setValue([...current, newCommand])
+    }
+  }
+
   #handleConsoleLogsUpdate(data: string[]) {
     this.consoleLogsContextProvider.setValue([
       ...(this.consoleLogsContextProvider.value || []),

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

@@ -13,23 +13,41 @@ import type { NightwatchBrowser, CommandStackFrame } from '../types.js'
 const log = logger('@wdio/nightwatch-devtools:browserProxy')
 
 export class BrowserProxy {
-  private browserProxied = false
+  /** Tracks which browser *instances* have already been proxied to avoid double-wrapping. */
+  private proxiedBrowsers = new WeakSet<object>()
   private commandStack: CommandStackFrame[] = []
   private lastCommandSig: string | null = null
   private currentTestFullPath: string | null = null
+  /**
+   * Tracks the last captured command so that consecutive retries of the same
+   * command (e.g. getText inside a waitFor loop) overwrite the previous entry
+   * rather than appending, showing only the final execution result.
+   */
+  private lastCapturedSig: string | null = null
+  private lastCapturedId: number | null = null
 
   constructor(
     private sessionCapturer: SessionCapturer,
     private testManager: TestManager,
     private getCurrentTest: () => any
   ) {}
 
+  /**
+   * Update the session capturer reference after a WebDriver session change.
+   * Does NOT re-wrap browser methods — wrapping is permanent per browser object.
+   */
+  updateSessionCapturer(capturer: SessionCapturer): void {
+    this.sessionCapturer = capturer
+  }
+
   /**
    * Reset command tracking for new test
    */
   resetCommandTracking(): void {
     this.commandStack = []
     this.lastCommandSig = null
+    this.lastCapturedSig = null
+    this.lastCapturedId = null
   }
 
   /**
@@ -82,7 +100,7 @@ export class BrowserProxy {
    * Wrap all browser commands to capture them
    */
   wrapBrowserCommands(browser: NightwatchBrowser): void {
-    if (this.browserProxied) {
+    if (this.proxiedBrowsers.has(browser as object)) {
       return
     }
 
@@ -123,7 +141,7 @@ export class BrowserProxy {
       wrappedMethods.push(methodName)
     })
 
-    this.browserProxied = true
+    this.proxiedBrowsers.add(browser as object)
     log.info(`✓ Wrapped ${wrappedMethods.length} browser methods`)
   }
 
@@ -243,8 +261,14 @@ export class BrowserProxy {
       const effectiveUid = currentTest?.uid ?? testUid
 
       if (effectiveUid) {
-        this.sessionCapturer
-          .captureCommand(
+        const isRetry =
+          cmdSig === this.lastCapturedSig && this.lastCapturedId !== null
+
+        if (isRetry) {
+          // Same command fired again (internal retry) — replace the previous
+          // entry so only the final result appears in the UI.
+          const { entry, oldTimestamp } = this.sessionCapturer.replaceCommand(
+            this.lastCapturedId!,
             methodName,
             logArgs,
             serializedResult,
@@ -253,18 +277,40 @@ export class BrowserProxy {
             callSource,
             commandTimestamp
           )
-          .then(() => {
-            const lastCommand =
-              this.sessionCapturer.commandsLog[
-                this.sessionCapturer.commandsLog.length - 1
-              ]
-            if (lastCommand) {
-              this.sessionCapturer.sendCommand(lastCommand)
-            }
-          })
-          .catch((err: any) =>
-            log.error(`Failed to capture ${methodName}: ${err.message}`)
-          )
+          this.lastCapturedId = entry._id ?? null
+          this.sessionCapturer.sendReplaceCommand(oldTimestamp, entry)
+        } else {
+          // New command — capture and track.
+          // captureCommand() pushes the entry to commandsLog synchronously
+          // before any async work (navigation perf capture), so we can grab
+          // the ID immediately after the call — before any microtask fires.
+          // This avoids the race where a Nightwatch retry callback executes
+          // before .then() sets lastCapturedId, causing missed dedup.
+          this.lastCapturedSig = cmdSig
+          this.lastCapturedId = null
+          this.sessionCapturer
+            .captureCommand(
+              methodName,
+              logArgs,
+              serializedResult,
+              undefined,
+              effectiveUid,
+              callSource,
+              commandTimestamp
+            )
+            .catch((err: any) =>
+              log.error(`Failed to capture ${methodName}: ${err.message}`)
+            )
+          // Read the entry synchronously — it was already pushed above.
+          const lastCommand =
+            this.sessionCapturer.commandsLog[
+              this.sessionCapturer.commandsLog.length - 1
+            ]
+          if (lastCommand) {
+            this.lastCapturedId = (lastCommand as any)._id ?? null
+            this.sessionCapturer.sendCommand(lastCommand)
+          }
+        }
       }
 
       // Forward to the user's original callback (if any)
@@ -330,9 +376,9 @@ export class BrowserProxy {
   }
 
   /**
-   * Check if browser is already proxied
+   * Check if a specific browser instance is already proxied
    */
-  isProxied(): boolean {
-    return this.browserProxied
+  isProxied(browser: NightwatchBrowser): boolean {
+    return this.proxiedBrowsers.has(browser as object)
   }
 }

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

@@ -49,6 +49,21 @@ export function resetSignatureCounters() {
   signatureCounters.clear()
 }
 
+/**
+ * Compute a purely deterministic UID from arbitrary string parts.
+ * Unlike generateStableUid this NEVER uses the signature counter, so calling
+ * it multiple times with the same inputs always returns the same value.
+ * Use this wherever the same entity (e.g. a Cucumber scenario) must map to
+ * the same UID across retries.
+ */
+export function deterministicUid(...parts: string[]): string {
+  const hash = parts
+    .join('::')
+    .split('')
+    .reduce((acc, char) => ((acc << 5) - acc + char.charCodeAt(0)) | 0, 0)
+  return `stable-${Math.abs(hash).toString(36)}`
+}
+
 // File patterns for test file identification
 const SPEC_FILE_PATTERN = /\/(test|spec|tests)\//i
 const SPEC_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i