@rvoh/psychic-spec-helpers 0.2.0 → 0.3.1-beta.10

package/dist/esm/src/feature/helpers/launchBrowser.js

@@ -3,7 +3,7 @@ export default async function launchBrowser(opts) {
     return await puppeteer.launch({
         browser: 'firefox',
         dumpio: process.env.DEBUG === '1',
-        headless: true,
+        headless: process.env.HEADLESS !== '0',
         ...opts,
     });
 }

package/dist/esm/src/feature/helpers/providePuppeteerViteMatchers.js

@@ -18,32 +18,32 @@ import toFill from '../matchers/toFill.js';
 export default function providePuppeteerViteMatchers() {
     ;
     global.expect.extend({
-        async toMatchTextContent(page, text) {
-            return await toMatchTextContent(page, text);
+        async toMatchTextContent(page, text, opts) {
+            return await toMatchTextContent(page, text, opts);
         },
         async toNotMatchTextContent(page, text) {
             return await toNotMatchTextContent(page, text);
         },
-        async toHaveSelector(page, cssSelector) {
-            return await toHaveSelector(page, cssSelector);
+        async toHaveSelector(page, cssSelector, opts) {
+            return await toHaveSelector(page, cssSelector, opts);
         },
         async toNotHaveSelector(page, cssSelector) {
             return await toNotHaveSelector(page, cssSelector);
         },
-        async toCheck(page, text) {
-            return await toCheck(page, text);
+        async toCheck(page, text, opts) {
+            return await toCheck(page, text, opts);
         },
-        async toClick(page, text) {
-            return await toClick(page, text);
+        async toClick(page, text, opts) {
+            return await toClick(page, text, opts);
         },
-        async toClickLink(page, text) {
-            return await toClickLink(page, text);
+        async toClickLink(page, text, opts) {
+            return await toClickLink(page, text, opts);
         },
-        async toClickButton(page, text) {
-            return await toClickButton(page, text);
+        async toClickButton(page, text, opts) {
+            return await toClickButton(page, text, opts);
         },
-        async toClickSelector(page, cssSelector) {
-            return await toClickSelector(page, cssSelector);
+        async toClickSelector(page, cssSelector, opts) {
+            return await toClickSelector(page, cssSelector, opts);
         },
         async toHavePath(page, path) {
             return await toHavePath(page, path);
@@ -51,20 +51,20 @@ export default function providePuppeteerViteMatchers() {
         async toHaveUrl(page, url) {
             return await toHaveUrl(page, url);
         },
-        async toHaveChecked(page, text) {
-            return await toHaveChecked(page, text);
+        async toHaveChecked(page, text, opts) {
+            return await toHaveChecked(page, text, opts);
         },
-        async toHaveUnchecked(page, checked) {
-            return await toHaveUnchecked(page, checked);
+        async toHaveUnchecked(page, checked, opts) {
+            return await toHaveUnchecked(page, checked, opts);
         },
-        async toHaveLink(page, text) {
-            return await toHaveLink(page, text);
+        async toHaveLink(page, text, opts) {
+            return await toHaveLink(page, text, opts);
         },
-        async toFill(page, cssSelector, text) {
-            return await toFill(page, cssSelector, text);
+        async toFill(page, cssSelector, text, opts) {
+            return await toFill(page, cssSelector, text, opts);
         },
-        async toUncheck(page, text) {
-            return await toUncheck(page, text);
+        async toUncheck(page, text, opts) {
+            return await toUncheck(page, text, opts);
         },
         async toEvaluate(argumentPassedToExpect, evaluationFn, opts) {
             return await evaluateWithRetryAndTimeout(argumentPassedToExpect, evaluationFn, opts);

package/dist/esm/src/feature/helpers/visit.js

@@ -1,6 +1,4 @@
-import launchPage from './launchPage.js';
-export default async function visit(path, { page, baseUrl = 'http://localhost:3000' } = {}) {
-    page ||= await launchPage();
+export default async function visit(path, { baseUrl = 'http://localhost:3000' } = {}) {
     await page.goto(`${baseUrl}/${path.replace(/^\//, '')}`);
     return page;
 }

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

@@ -1,23 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toCheck(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
-        const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
-        if (isChecked)
-            return evaluationFailure(`A checkbox was found with "${expectedText}", but it is already checked`);
-        await checkbox.click();
-        const isCheckedNow = await page.evaluate(checkbox => checkbox.checked, checkbox);
+export default async function toCheck(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`label::-p-text(${expectedText}`, opts);
+        await el.click();
         return {
-            pass: isCheckedNow,
-            actual: expectedText,
+            pass: true,
+            message: () => {
+                throw new Error('Cannot negate toCheck');
+            },
         };
-    }, {
-        successText: r => `Expected page to have checkable checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have checkable checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have checkable element with text: "${expectedText}"`,
+        };
+    }
 }

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;
-        }
+export default async function toClick(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`*::-p-text(${expectedText})`, opts);
+        await el.click();
         return {
             pass: true,
-            actual: expectedText,
+            message: () => {
+                throw new Error('Cannot negate toClick');
+            },
         };
-    }, {
-        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/toClickButton.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 toClickButton(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            const el = await page.locator(`button ::-p-text(${expectedText})`).setTimeout(10).wait();
-            await el.click();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+export default async function toClickButton(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector('button::-p-text(Submit)', opts);
+        await el.click();
         return {
             pass: true,
-            actual: expectedText,
+            message: () => {
+                throw new Error('Cannot negate toClickLink');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable button with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable button with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable link with matching text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toClickLink.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 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();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+export default async function toClickLink(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`a ::-p-text(${expectedText})`, opts);
+        await el.click();
         return {
             pass: true,
-            actual: expectedText,
+            message: () => {
+                throw new Error('Cannot negate toClickLink');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable link with matching text: "${expectedText}"`,
+        };
+    }
 }

package/dist/esm/src/feature/matchers/toClickSelector.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 toClickSelector(page, cssSelector) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            const el = await page.locator(cssSelector).setTimeout(10).wait();
-            await el.click();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(cssSelector);
-            throw err;
-        }
+export default async function toClickSelector(page, cssSelector, opts) {
+    try {
+        const el = await page.waitForSelector(cssSelector, opts);
+        await el.click();
         return {
             pass: true,
-            actual: cssSelector,
+            message: () => {
+                throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable selector with text: "${cssSelector}"`,
-        failureText: () => `Expected page not to have clickable selector with text: "${cssSelector}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have clickable element with matching selector: "${cssSelector}"`,
+        };
+    }
 }

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

@@ -1,21 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toFill(page, cssSelector, text) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        try {
-            await page.type(cssSelector, text);
-        }
-        catch {
-            return evaluationFailure(text);
-        }
+export default async function toFill(page, cssSelector, text, opts) {
+    try {
+        await page.waitForSelector(cssSelector, opts);
+        await page.type(cssSelector, text);
         return {
             pass: true,
-            actual: text,
+            message: () => {
+                throw new Error('cannot negate toFill');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable link with text: "${text}"`,
-        failureText: () => `Expected page not to have clickable link with text: "${text}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `failed to fill input matching selector ${cssSelector} with text "text"`,
+        };
+    }
 }

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

@@ -1,19 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toHaveChecked(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
+export default async function toHaveChecked(page, expectedText, opts) {
+    try {
+        const checkbox = await page.waitForSelector(`input[type="checkbox"][value="${expectedText}"]`, opts);
         const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
         return {
             pass: isChecked,
-            actual: expectedText,
+            message: () => {
+                throw new Error('cannot negate toHaveChecked, try toHaveUnchecked');
+            },
         };
-    }, {
-        successText: r => `Expected page to have checked checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have checked checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page to have checked checkbox with text: "${expectedText}"`,
+        };
+    }
 }

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

@@ -1,25 +1,17 @@
-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 toHaveLink(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        let el = undefined;
-        try {
-            el = await page.locator(`a ::-p-text(${expectedText})`).setTimeout(10).wait();
-        }
-        catch (err) {
-            if (err instanceof TimeoutError)
-                return evaluationFailure(expectedText);
-            throw err;
-        }
+export default async function toHaveLink(page, expectedText, opts) {
+    try {
+        await page.waitForSelector(`a ::-p-text(${expectedText})`, opts);
         return {
-            pass: !!el,
-            actual: expectedText,
+            pass: true,
+            message: () => {
+                throw new Error('cannot negate toFill');
+            },
         };
-    }, {
-        successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
-        failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page not to have checked checkbox with text: "${expectedText}"`,
+        };
+    }
 }

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

@@ -9,7 +9,9 @@ export default async function toHavePath(page, expectedPath) {
             actual: expectedPath,
         };
     }, {
-        successText: () => `Expected page to have path: "${expectedPath}"`,
+        successText: () => {
+            throw new Error('cannot negate toHavePath');
+        },
         failureText: () => `Expected page not to have path: "${expectedPath}"`,
     });
 }

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

@@ -1,14 +1,20 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toHaveSelector(page, expectedSelector) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
+export default async function toHaveSelector(page, selector, opts) {
+    try {
+        await page.waitForSelector(selector, opts);
         return {
-            pass: !!(await page.$(expectedSelector)),
-            actual: expectedSelector,
+            pass: true,
+            message: () => {
+                throw new Error('Cannot negate toHaveSelector, use toNotHaveSelector instead');
+            },
         };
-    }, {
-        successText: r => `Expected ${r} to have selector: ${expectedSelector}`,
-        failureText: r => `Expected ${r} not to have selector: ${expectedSelector}`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `
+expected selector: ${selector}
+but no selector was found
+      `,
+        };
+    }
 }

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

@@ -1,19 +1,18 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toHaveUnchecked(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
+export default async function toHaveUnchecked(page, expectedText, opts) {
+    try {
+        const checkbox = await page.waitForSelector(`input[type="checkbox"][value="${expectedText}"]`, opts);
         const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
         return {
             pass: !isChecked,
-            actual: expectedText,
+            message: () => {
+                throw new Error('cannot negate toHaveUnchecked, try toHaveChecked');
+            },
         };
-    }, {
-        successText: r => `Expected page to have unchecked checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have unchecked checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `Expected page not to have checked checkbox with text: "${expectedText}"`,
+        };
+    }
 }

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

@@ -1,16 +1,22 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import getAllTextContentFromPage from '../internal/getAllTextContentFromPage.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toMatchTextContent(argumentPassedToExpect, expected) {
-    return await evaluateWithRetryAndTimeout(argumentPassedToExpect, async () => {
-        requirePuppeteerPage(argumentPassedToExpect);
-        const actual = await getAllTextContentFromPage(argumentPassedToExpect);
+export default async function toMatchTextContent(page, text, { selector = 'body' } = {}) {
+    try {
+        await page.waitForSelector(`${selector}::-p-text(${text.replace(/"/g, '\\"')})`);
         return {
-            pass: actual.includes(expected),
-            actual,
+            pass: true,
+            message: () => {
+                throw new Error('Cannot negate toMatchTextContent, use toNotMatchTextContent instead');
+            },
         };
-    }, {
-        successText: r => `Expected ${r} to match text ${expected}`,
-        failureText: r => `Expected ${r} not to match text ${expected}`,
-    });
+    }
+    catch {
+        return {
+            pass: false,
+            message: () => `
+expected ${selector} with text:
+        ${text}
+
+but no text was found within that selector
+      `,
+        };
+    }
 }

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/esm/src/feature/matchers/toUncheck.js

@@ -1,23 +1,26 @@
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
-import evaluationFailure from '../internal/evaluationFailure.js';
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
-export default async function toUncheck(page, expectedText) {
-    return await evaluateWithRetryAndTimeout(page, async () => {
-        requirePuppeteerPage(page);
-        const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`);
-        if (!checkbox)
-            return evaluationFailure(`A checkbox was not found with "${expectedText}"`);
-        const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
+export default async function toUncheck(page, expectedText, opts) {
+    try {
+        const el = await page.waitForSelector(`label::-p-text(${expectedText}`, opts);
+        await el.click();
+        const isChecked = await page.evaluate(checkbox => checkbox.checked, el);
         if (!isChecked)
-            return evaluationFailure(`A checkbox was found with "${expectedText}", but it is already unchecked`);
-        await checkbox.click();
-        const isCheckedNow = await page.evaluate(checkbox => checkbox.checked, checkbox);
+            return {
+                pass: false,
+                message: () => `A checkbox was found with "${expectedText}", but it is already unchecked`,
+            };
+        await el.click();
+        const isUncheckedNow = await page.evaluate(checkbox => checkbox.checked, el);
         return {
-            pass: !isCheckedNow,
-            actual: expectedText,
+            pass: isUncheckedNow,
+            message: () => {
+                throw new Error('Cannot negate toUncheck, try toCheck');
+            },
         };
-    }, {
-        successText: r => `Expected page to have uncheckable checkbox with text: "${expectedText}"`,
-        failureText: r => `Expected page not to have uncheckable checkbox with text: "${expectedText}"`,
-    });
+    }
+    catch (error) {
+        return {
+            pass: false,
+            message: `Expected page to have checkable element with text: "${expectedText}"`,
+        };
+    }
 }

package/dist/types/src/feature/helpers/visit.d.ts

@@ -1,5 +1,3 @@
-import { Page } from 'puppeteer';
-export default function visit(path: string, { page, baseUrl }?: {
-    page?: Page;
+export default function visit(path: string, { baseUrl }?: {
     baseUrl?: string;
-}): Promise<Page>;
+}): Promise<import("puppeteer").Page>;

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

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