@rvoh/psychic-spec-helpers 3.3.0 → 3.4.0

package/dist/esm/src/feature/matchers/toHaveSelector.js

@@ -1,7 +1,14 @@
 import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js';
 export default async function toHaveSelector(page, selector, opts) {
+    // Presence-only contract: this matcher asserts that the selector is
+    // attached to the DOM, regardless of visibility. Strip visible/hidden so
+    // a caller-passed { visible: true } can't narrow the check to also
+    // require visibility.
+    const waitForOpts = applyDefaultWaitForOpts(opts);
+    delete waitForOpts.visible;
+    delete waitForOpts.hidden;
     try {
-        await page.waitForSelector(selector, applyDefaultWaitForOpts(opts));
+        await page.waitForSelector(selector, waitForOpts);
         return {
             pass: true,
             message: () => {

package/dist/esm/src/feature/matchers/toNotHaveSelector.js

@@ -1,18 +1,35 @@
 import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js';
+import sleep from '../../shared/sleep.js';
 export default async function toNotHaveSelector(page, selector, opts) {
-    try {
-        await page.waitForSelector(selector, { hidden: true, ...applyDefaultWaitForOpts(opts) });
-        return {
-            pass: true,
-            message: () => {
-                throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead');
-            },
-        };
-    }
-    catch {
-        return {
-            pass: false,
-            message: () => `Expected page to not have visible selector, but it did: ${selector}`,
-        };
+    // Presence-only contract: this matcher asserts that the selector is
+    // absent from the DOM, regardless of visibility. A present-but-hidden
+    // element must FAIL this matcher, so we poll for true DOM absence via
+    // page.$ (rather than relying on waitForSelector({ hidden: true }),
+    // which only asserts invisibility). page.$ (not document.querySelector)
+    // is used so Puppeteer's extended selectors like ::-p-text keep working.
+    const timeout = applyDefaultWaitForOpts(opts).timeout ?? 5000;
+    const interval = 50;
+    const startTime = Date.now();
+    async function poll() {
+        const element = await page.$(selector);
+        if (!element) {
+            return {
+                pass: true,
+                message: () => {
+                    throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead');
+                },
+            };
+        }
+        if (Date.now() >= startTime + timeout) {
+            await element.dispose();
+            return {
+                pass: false,
+                message: () => `Expected page to not have selector, but it did: ${selector}`,
+            };
+        }
+        await element.dispose();
+        await sleep(interval);
+        return await poll();
     }
+    return await poll();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@rvoh/psychic-spec-helpers",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "psychic framework spec helpers",
   "author": "RVO Health",
   "publishConfig": {

package/src/feature/matchers/toHaveSelector.ts

@@ -6,8 +6,16 @@ export default async function toHaveSelector(
   selector: string,
   opts?: WaitForSelectorOptions
 ) {
+  // Presence-only contract: this matcher asserts that the selector is
+  // attached to the DOM, regardless of visibility. Strip visible/hidden so
+  // a caller-passed { visible: true } can't narrow the check to also
+  // require visibility.
+  const waitForOpts = applyDefaultWaitForOpts(opts)
+  delete waitForOpts.visible
+  delete waitForOpts.hidden
+
   try {
-    await page.waitForSelector(selector, applyDefaultWaitForOpts(opts))
+    await page.waitForSelector(selector, waitForOpts)
     return {
       pass: true,
       message: () => {

package/src/feature/matchers/toNotHaveSelector.ts

@@ -1,23 +1,45 @@
 import { Page, WaitForSelectorOptions } from 'puppeteer'
 import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js'
+import sleep from '../../shared/sleep.js'
 
 export default async function toNotHaveSelector(
   page: Page,
   selector: string,
   opts?: WaitForSelectorOptions
 ) {
-  try {
-    await page.waitForSelector(selector, { hidden: true, ...applyDefaultWaitForOpts(opts) })
-    return {
-      pass: true,
-      message: () => {
-        throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead')
-      },
+  // Presence-only contract: this matcher asserts that the selector is
+  // absent from the DOM, regardless of visibility. A present-but-hidden
+  // element must FAIL this matcher, so we poll for true DOM absence via
+  // page.$ (rather than relying on waitForSelector({ hidden: true }),
+  // which only asserts invisibility). page.$ (not document.querySelector)
+  // is used so Puppeteer's extended selectors like ::-p-text keep working.
+  const timeout = applyDefaultWaitForOpts(opts).timeout ?? 5000
+  const interval = 50
+  const startTime = Date.now()
+
+  async function poll(): Promise<{ pass: boolean; message: () => string }> {
+    const element = await page.$(selector)
+    if (!element) {
+      return {
+        pass: true,
+        message: () => {
+          throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead')
+        },
+      }
     }
-  } catch {
-    return {
-      pass: false,
-      message: () => `Expected page to not have visible selector, but it did: ${selector}`,
+
+    if (Date.now() >= startTime + timeout) {
+      await element.dispose()
+      return {
+        pass: false,
+        message: () => `Expected page to not have selector, but it did: ${selector}`,
+      }
     }
+
+    await element.dispose()
+    await sleep(interval)
+    return await poll()
   }
+
+  return await poll()
 }