Merge pull request #484 from webdriverio/fix/481-service-assert-target

Name a node:assert target from value provenance in the WDIO service

Author: vishnuv688

.changeset/assert-target-per-test.md

@@ -0,0 +1,7 @@
+---
+'@wdio/devtools-service': patch
+'@wdio/selenium-devtools': patch
+'@wdio/nightwatch-devtools': patch
+---
+
+A `node:assert` row only names an element read in the same test (or Cucumber scenario). An assertion in a later test, such as `assert.ok(true)`, no longer boxes an element an earlier test read the same value from. With the WebdriverIO service, a `browser.getTitle()` issued while one of the service's own title reads is still pending keeps its row in the Actions list.

.changeset/service-assert-target.md

@@ -0,0 +1,5 @@
+---
+'@wdio/devtools-service': patch
+---
+
+A `node:assert` row names the element whose read produced the asserted value, and none for a page-level value: `assert.notEqual(await browser.getTitle(), 'Secure Area')` no longer boxes the last element the test resolved. The test's own `browser.getTitle()` is now a `Page.getTitle` row in the Actions list, as in the other adapters.

CLAUDE.md

@@ -3,7 +3,6 @@ import {
   CONDITION_WAIT_READS,
   HELPER_WAIT_READ,
   KNOWN_DEBT,
-  PAGE_TITLE_TEST,
   RULES
 } from './constants.js'
 import { anyOf, hunk } from './gap-matchers.js'
@@ -17,9 +16,8 @@ import type {
   Violation
 } from './types.js'
 
-const [WAITS, PAGE_TITLE, MISSING] = [
+const [WAITS, MISSING] = [
   'waits on what the page shows',
-  PAGE_TITLE_TEST,
   'times out waiting for a missing element'
 ].map(scenarioIndex)
 
@@ -63,41 +61,12 @@ export const KNOWN_GAPS: KnownGap[] = [
     timingDependent: true
   },
   ...BIDI_MODES.flatMap((bidi) => [
-    ...serviceGaps(bidi),
     ...nightwatchGaps(bidi),
     ...seleniumGaps(bidi),
     ...pythonGaps(bidi)
   ])
 ]
 
-function serviceGaps(bidi: BidiMode): KnownGap[] {
-  const adapter = 'devtools-service'
-  const reason = KNOWN_DEBT.serviceAssertTarget
-  return [
-    {
-      adapter,
-      bidi,
-      rules: [RULES.pageAssertNamesNoElement],
-      only: (message) =>
-        message === 'assert.notEqual on the page title names h2',
-      reason
-    },
-    {
-      adapter,
-      bidi,
-      rules: [RULES.agreeOnActions],
-      only: hunk(
-        PAGE_TITLE,
-        'Element.getText h2',
-        adapter,
-        'Assert.notEqual h2',
-        'Page.getTitle, Assert.notEqual'
-      ),
-      reason
-    }
-  ]
-}
-
 /** Nightwatch's scenario gaps in one mode, each an adapter bug with its Known debt entry. */
 function nightwatchGaps(bidi: BidiMode): KnownGap[] {
   const adapter = 'nightwatch-devtools'

packages/conformance/src/allowlist.ts

@@ -203,7 +203,6 @@ const SELENIUM_WAIT_DEBT =
 
 /** Why each scenario gap exists: the limitation, and the Known debt entry that describes it. */
 export const KNOWN_DEBT = {
-  serviceAssertTarget: `The WebdriverIO service stamps a node:assert row with the last element it resolved and hides the user's own getTitle, so an assertion on the page title boxes the heading read before it. ${debt('The WDIO service boxes the last element it resolved for an assertion on the page title', '#481')}`,
   conditionWait: `A passing condition wait shows as its reads in Selenium and Python, which have no row for the wait itself, as one Browser.waitForFunction row in the WebdriverIO service, which hides the reads inside it, and as both in Nightwatch. ${debt('A condition wait shows its reads in some adapters and one wait row in others', '#464')}`,
   seleniumWait: `A successful driver.wait() has no row of its own: its polls are findElements rows, which the trace vocabulary leaves unmapped. ${debt(SELENIUM_WAIT_DEBT, '#464')}`,
   seleniumFailedWait: `A timed-out driver.wait() is a wait row named after its condition, mapped to Browser.waitForFunction with no target, where the other adapters show Element.waitForExist on the selector. ${debt(SELENIUM_WAIT_DEBT, '#464')}`,

packages/conformance/src/constants.ts

@@ -59,6 +59,11 @@ export function rememberReadValue(
   }
 }
 
+/** Called at each test start: an earlier test's read would otherwise box its element for a later `assert.ok(true)`. */
+export function clearReadValues(): void {
+  selectorByReadValue.clear()
+}
+
 /** The element locator this value was read from — undefined when an element read
  *  wasn't its most recent producer. */
 export function selectorForReadValue(value: unknown): string | undefined {

packages/core/src/read-value-locators.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import {
+  clearReadValues,
   rememberReadValue,
   resolveAssertTargetFromArgs,
   selectorForReadValue
@@ -144,3 +145,18 @@ describe('resolveAssertTargetFromArgs', () => {
     ).toBe('#handle')
   })
 })
+
+describe('clearReadValues', () => {
+  it('forgets every producer, so a later assertion on the same value names nothing', () => {
+    rememberReadValue(true, '#remember-me')
+    rememberReadValue('Example Domain', undefined)
+    clearReadValues()
+    expect(selectorForReadValue(true)).toBeUndefined()
+    expect(resolveAssertTargetFromArgs([true])).toBeUndefined()
+    // The no-element sentinel goes too: a cleared value no longer ends the lookup.
+    rememberReadValue('expected-after-clear', '#fresh')
+    expect(
+      resolveAssertTargetFromArgs(['Example Domain', 'expected-after-clear'])
+    ).toBe('#fresh')
+  })
+})

packages/core/tests/read-value-locators.test.ts

@@ -16,18 +16,24 @@ const log = logger('@wdio/nightwatch-devtools:assertCapture')
 /**
  * Patch node:assert once per process. Getters are read at capture time — the
  * capturer is created lazily in session init and the test UID changes per test.
+ * `scopeReadValues` runs before each lookup so an assert that precedes its
+ * test's first command still cannot resolve against an earlier test's reads.
  */
 export function wireAssertCapture(
   getCapturer: () => SessionCapturer | undefined,
-  getTestUid: () => string | undefined
+  getTestUid: () => string | undefined,
+  scopeReadValues: () => void = () => {}
 ): void {
   patchNodeAssert(
     (cmd) => captureAssert(getCapturer(), getTestUid(), cmd),
     (level, message) => log[level](message),
     // No handle resolver: Nightwatch commands take selector strings, so an
     // element object never reaches an assert — only the value's provenance,
     // recorded by the command path (BrowserProxy), can name the target.
-    (args) => resolveAssertTargetFromArgs(args)
+    (args) => {
+      scopeReadValues()
+      return resolveAssertTargetFromArgs(args)
+    }
   )
 }
 

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

@@ -16,6 +16,7 @@ import { NativeAssertRecorder } from './nativeAssertRecorder.js'
 import {
   RetryTracker,
   beginInputDispatch,
+  clearReadValues,
   rememberReadValue,
   toError
 } from '@wdio/devtools-core'
@@ -67,6 +68,9 @@ export class BrowserProxy {
    */
   private browser: NightwatchBrowser | null = null
 
+  /** The test core's value registry currently holds reads for; see {@link scopeReadValuesToRowTest}. */
+  private readValueTestUid: string | undefined
+
   constructor(
     private readonly sessionCapturer: SessionCapturer,
     private testManager: TestManager,
@@ -104,6 +108,20 @@ export class BrowserProxy {
     return this.rowTest()?.uid
   }
 
+  /**
+   * Forget the values an earlier test read once the running test changes. The
+   * lifecycle reset below fires once per MODULE on the BDD interface, so this
+   * per-`it` live read is what keeps one `it`'s reads from naming another's
+   * assertion target. Called before every record and every lookup.
+   */
+  scopeReadValuesToRowTest(): void {
+    const uid = this.rowTestUid()
+    if (uid !== this.readValueTestUid) {
+      clearReadValues()
+      this.readValueTestUid = uid
+    }
+  }
+
   /** Per-command-scope dedup state only. Cucumber calls this per STEP, so it
    *  must not touch the native-assert buffer — that buffer spans the whole
    *  scenario and is drained once, at the scenario's pre-quit hook. */
@@ -118,6 +136,8 @@ export class BrowserProxy {
   resetTestTracking(): void {
     this.resetCommandTracking()
     this.assertRecorder.clear()
+    clearReadValues()
+    this.readValueTestUid = undefined
   }
 
   /** Hand off this test's recorded native-assertion calls and clear the
@@ -437,6 +457,7 @@ export class BrowserProxy {
     callbackResult: unknown
   ): unknown {
     const result = serializeCommandResult(callbackResult, methodName)
+    this.scopeReadValuesToRowTest()
     rememberReadValue(result, commandTargetSelector(methodName, logArgs))
     return result
   }

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

@@ -400,7 +400,8 @@ class NightwatchDevToolsPlugin {
         // Rows are tagged per-`it` (BrowserProxy.rowTestUid); `#currentTestUid`
         // — the lifecycle test, which the BDD interface pins to the module's
         // first `it` — is only the fallback, and stays the artifact/slice key.
-        () => this.browserProxy?.rowTestUid() ?? this.#currentTestUid()
+        () => this.browserProxy?.rowTestUid() ?? this.#currentTestUid(),
+        () => this.browserProxy?.scopeReadValuesToRowTest()
       )
     }
   }