@rvoh/psychic-spec-helpers 0.3.1-fgbeta-7 → 0.3.1-fgbeta-9

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

@@ -1,25 +1,18 @@
-import { TimeoutError } from 'puppeteer';
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
 export default async function toClick(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            const el = await page.locator(`*::-p-text(${expectedText})`).setTimeout(5000).wait();
-            await el.click();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+    try {
+        const el = await page.waitForSelector(`*::-p-text(${expectedText})`);
+        await el.click();
         return {
             pass: true,
-            actual: expectedText,
+            message: () => {
+                throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable element with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable element with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable element with text: "${expectedText}"`,
+        };
+    }
 }

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

@@ -6,8 +6,8 @@ export default async function toClickLink(page, expectedText) {
     return await evaluateWithRetryAndTimeout(page, async () => {
         requirePuppeteerPage(page);
         try {
-            const el = await page.locator(`a ::-p-text(${expectedText})`).setTimeout(5000).wait();
-            await el.click();
+            ;
+            (await page.$(`a ::-p-text(${expectedText})`)).click();
         }
         catch (err) {
             if (err instanceof TimeoutError)

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

@@ -6,8 +6,8 @@ export default async function toClickSelector(page, cssSelector) {
     return await evaluateWithRetryAndTimeout(page, async () => {
         requirePuppeteerPage(page);
         try {
-            const el = await page.locator(cssSelector).setTimeout(5000).wait();
-            await el.click();
+            ;
+            (await page.$(cssSelector)).click();
         }
         catch (err) {
             if (err instanceof TimeoutError)

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

@@ -3,10 +3,9 @@ export default async function toHaveSelector(page, selector) {
         await page.waitForSelector(selector);
         return {
             pass: true,
-            message: () => `
-expected no selector: ${selector}
-but the selector was found
-      `,
+            message: () => {
+                throw new Error('Cannot negate toHaveSelector, use toNotHaveSelector instead');
+            },
         };
     }
     catch {

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

@@ -3,12 +3,9 @@ export default async function toMatchTextContent(page, text, { selector = 'body'
         await page.waitForSelector(`${selector}::-p-text(${text.replace(/"/g, '\\"')})`);
         return {
             pass: true,
-            message: () => `
-expected no ${selector} with text:
-        ${text}
-
-but text was found with that selector
-      `,
+            message: () => {
+                throw new Error('Cannot negate toMatchTextContent, use toNotMatchTextContent instead');
+            },
         };
     }
     catch {

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

@@ -1,14 +1,16 @@
 import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
 import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toNotHaveSelector(page, expectedSelector) {
+export default async function toNotHaveSelector(page, selector) {
     return await evaluateWithRetryAndTimeout(page, async () => {
         requirePuppeteerPage(page);
         return {
-            pass: !(await page.$(expectedSelector)),
-            actual: expectedSelector,
+            pass: !(await page.$(selector)),
+            actual: selector,
         };
     }, {
-        successText: r => `Expected ${r} not to have selector: ${expectedSelector}`,
-        failureText: r => `Expected ${r} to have selector: ${expectedSelector}`,
+        successText: () => {
+            throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead');
+        },
+        failureText: r => `Expected ${r} to have selector: ${selector}`,
     });
 }

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

@@ -10,7 +10,9 @@ export default async function toNotMatchTextContent(argumentPassedToExpect, expe
             actual,
         };
     }, {
-        successText: r => `Expected ${r} not to match text ${expected}`,
+        successText: () => {
+            throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead');
+        },
         failureText: r => `Expected ${r} to match text ${expected}`,
     });
 }

package/dist/types/src/feature/matchers/toClick.d.ts

@@ -1,5 +1,8 @@
 import { Page } from 'puppeteer';
 export default function toClick(page: Page, expectedText: string): Promise<{
-    message: () => string;
     pass: boolean;
+    message: () => never;
+} | {
+    pass: boolean;
+    message: string;
 }>;

package/dist/types/src/feature/matchers/toNotHaveSelector.d.ts

@@ -1,5 +1,5 @@
 import { Page } from 'puppeteer';
-export default function toNotHaveSelector(page: Page, expectedSelector: string): Promise<{
+export default function toNotHaveSelector(page: Page, selector: string): Promise<{
     message: () => string;
     pass: boolean;
 }>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@rvoh/psychic-spec-helpers",
-  "version": "0.3.1-fgbeta-7",
+  "version": "0.3.1-fgbeta-9",
   "description": "psychic framework spec helpers",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",

package/src/feature/matchers/toClick.ts

@@ -4,27 +4,20 @@ import evaluationFailure from '../internal/evaluationFailure.js'
 import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
 
 export default async function toClick(page: Page, expectedText: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+  try {
+    const el = await page.waitForSelector(`*::-p-text(${expectedText})`)
+    await el!.click()
 
-      try {
-        const el = await page.locator(`*::-p-text(${expectedText})`).setTimeout(5000).wait()
-        await el.click()
-      } catch (err) {
-        if (err instanceof TimeoutError) return evaluationFailure(expectedText)
-        throw err
-      }
-
-      return {
-        pass: true,
-        actual: expectedText,
-      }
-    },
-    {
-      successText: () => `Expected page to have clickable element with text: "${expectedText}"`,
-      failureText: () => `Expected page not to have clickable element with text: "${expectedText}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead')
+      },
+    }
+  } catch (error) {
+    return {
+      pass: false,
+      message: `Expected page to have clickable element with text: "${expectedText}"`,
     }
-  )
+  }
 }

package/src/feature/matchers/toClickLink.ts

@@ -10,8 +10,7 @@ export default async function toClickLink(page: Page, expectedText: string) {
       requirePuppeteerPage(page)
 
       try {
-        const el = await page.locator(`a ::-p-text(${expectedText})`).setTimeout(5000).wait()
-        await el.click()
+        ;(await page.$(`a ::-p-text(${expectedText})`))!.click()
       } catch (err) {
         if (err instanceof TimeoutError) return evaluationFailure(expectedText)
         throw err

package/src/feature/matchers/toClickSelector.ts

@@ -10,8 +10,7 @@ export default async function toClickSelector(page: Page, cssSelector: string) {
       requirePuppeteerPage(page)
 
       try {
-        const el = await page.locator(cssSelector).setTimeout(5000).wait()
-        await el.click()
+        ;(await page.$(cssSelector))!.click()
       } catch (err) {
         if (err instanceof TimeoutError) return evaluationFailure(cssSelector)
         throw err

package/src/feature/matchers/toHaveSelector.ts

@@ -5,10 +5,9 @@ export default async function toHaveSelector(page: Page, selector: string) {
     await page.waitForSelector(selector)
     return {
       pass: true,
-      message: () => `
-expected no selector: ${selector}
-but the selector was found
-      `,
+      message: () => {
+        throw new Error('Cannot negate toHaveSelector, use toNotHaveSelector instead')
+      },
     }
   } catch {
     return {

package/src/feature/matchers/toMatchTextContent.ts

@@ -9,12 +9,9 @@ export default async function toMatchTextContent(
     await page.waitForSelector(`${selector}::-p-text(${text.replace(/"/g, '\\"')})`)
     return {
       pass: true,
-      message: () => `
-expected no ${selector} with text:
-        ${text}
-
-but text was found with that selector
-      `,
+      message: () => {
+        throw new Error('Cannot negate toMatchTextContent, use toNotMatchTextContent instead')
+      },
     }
   } catch {
     return {

package/src/feature/matchers/toNotHaveSelector.ts

@@ -2,20 +2,22 @@ import { Page } from 'puppeteer'
 import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
 import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
 
-export default async function toNotHaveSelector(page: Page, expectedSelector: string) {
+export default async function toNotHaveSelector(page: Page, selector: string) {
   return await evaluateWithRetryAndTimeout(
     page,
     async () => {
       requirePuppeteerPage(page)
 
       return {
-        pass: !(await page.$(expectedSelector)),
-        actual: expectedSelector,
+        pass: !(await page.$(selector)),
+        actual: selector,
       }
     },
     {
-      successText: r => `Expected ${r} not to have selector: ${expectedSelector}`,
-      failureText: r => `Expected ${r} to have selector: ${expectedSelector}`,
+      successText: () => {
+        throw new Error('Cannot negate toNotHaveSelector, use toHaveSelector instead')
+      },
+      failureText: r => `Expected ${r} to have selector: ${selector}`,
     }
   )
 }

package/src/feature/matchers/toNotMatchTextContent.ts

@@ -19,7 +19,9 @@ export default async function toNotMatchTextContent(
       }
     },
     {
-      successText: r => `Expected ${r} not to match text ${expected}`,
+      successText: () => {
+        throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead')
+      },
       failureText: r => `Expected ${r} to match text ${expected}`,
     }
   )