@rvoh/psychic-spec-helpers 0.2.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2025 RVOHealth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

package/README.md

@@ -0,0 +1,68 @@
+# Psychic spec helpers
+
+This repo provides spec helpers to be used in conjunction with the [psychic web framework](https://github.com/rvohealth/psychic).
+
+## Getting started
+
+1. Add this repo as a dev dependency in your psychic project (this is done by default for psychic apps, but worth mentioning in case it has been removed from your repo).
+
+```bash
+yarn add --dev @rvohealth/psychic-spec-helpers
+```
+
+2. import psychic spec helpers in your jest setup. This is automatically set up when provisioning a new psychic app, so you should only need to do this with an a-typical setup.
+
+```ts
+// spec/unit/setup/hooks.ts
+import "@rvohealth/psychic-spec-helpers";
+...
+```
+
+3. import and use the provided spec helpers:
+
+```ts
+import { specRequest as request } from '@rvohealth/psychic-spec-helpers'
+import { PsychicController } from '@rvohealth/psychic'
+
+describe('V1/Host/PlacesController', () => {
+  let user: User
+  let host: Host
+
+  beforeEach(async () => {
+    await request.init(PsychicServer)
+    user = await createUser()
+  })
+
+  describe('GET index', () => {
+    function subject(expectedStatus: number = 200) {
+      return request.get('/v1/host/places', expectedStatus, {
+        headers: addEndUserAuthHeader(request, user, {}),
+      })
+    }
+
+    it('returns the index of Places', async () => {
+      const place = await createPlace({ style: 'cabin', name: 'My cabin' })
+      await createHostPlace({ host, place })
+      const results = (await subject()).body
+
+      expect(results).toEqual([
+        expect.objectContaining({
+          id: place.id,
+          style: 'cabin',
+          name: 'My cabin',
+        }),
+      ])
+    })
+  })
+})
+```
+
+## Questions?
+
+- **Ask them on [Stack Overflow](https://stackoverflow.com)**, using the `[psychic]` tag.
+
+## Contributing
+
+Psychic is an open source library, so we encourage you to actively contribute. Visit our [Contributing](https://github.com/rvohealth/psychic-spec-helpers/CONTRIBUTING.md) guide to learn more about the processes we use for submitting pull requests or issues.
+
+Are you trying to report a possible security vulnerability? Visit our [Security Policy](https://github.com/rvohealth/psychic-spec-helpers/SECURITY.md) for guidelines about how to proceed.

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

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

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

@@ -0,0 +1,5 @@
+import launchBrowser from './launchBrowser.js';
+export default async function launchPage(opts) {
+    const browser = await launchBrowser(opts);
+    return browser.newPage();
+}

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

@@ -0,0 +1,89 @@
+import { spawn } from 'child_process';
+import { createServer } from 'net';
+import sleep from '../../shared/sleep.js';
+let serverProcess = undefined;
+export default async function launchViteServer({ port = 3000, cmd = 'yarn client', timeout = 5000, } = {}) {
+    if (serverProcess)
+        return;
+    if (process.env.DEBUG === '1')
+        console.log('Starting server...');
+    const [_cmd, ...args] = cmd.split(' ');
+    serverProcess = spawn(_cmd, args, {
+        detached: true,
+        env: {
+            ...process.env,
+            BROWSER: 'none',
+            VITE_PSYCHIC_ENV: 'test',
+        },
+    });
+    await waitForPort(port, timeout);
+    serverProcess.stdout.on('data', data => {
+        if (process.env.DEBUG === '1')
+            console.log(`Server output: ${data}`);
+    });
+    serverProcess.on('error', err => {
+        throw err;
+    });
+    serverProcess.stdout.on('data', data => {
+        if (process.env.DEBUG === '1')
+            console.log(`Server output: ${data}`);
+    });
+    serverProcess.stderr.on('data', data => {
+        if (process.env.DEBUG === '1')
+            console.error(`Server error: ${data}`);
+    });
+    serverProcess.on('error', err => {
+        console.error(`Server process error: ${err}`);
+    });
+    serverProcess.on('close', code => {
+        if (process.env.DEBUG === '1')
+            console.log(`Server process exited with code ${code}`);
+    });
+}
+export function stopViteServer() {
+    if (serverProcess?.pid) {
+        if (process.env.DEBUG === '1')
+            console.log('Stopping server...');
+        // serverProcess.kill('SIGINT')
+        process.kill(-serverProcess.pid, 'SIGKILL');
+        serverProcess = undefined;
+        if (process.env.DEBUG === '1')
+            console.log('server stopped');
+    }
+}
+async function isPortAvailable(port) {
+    return new Promise(resolve => {
+        const server = createServer()
+            .once('error', err => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        })
+            .once('listening', () => {
+            server.close();
+            resolve(true);
+        })
+            .listen(port, '127.0.0.1');
+    });
+}
+async function waitForPort(port, timeout = 5000) {
+    if (await isPortAvailable(port)) {
+        return true;
+    }
+    const startTime = Date.now();
+    async function recursiveWaitForPort() {
+        if (await isPortAvailable(port)) {
+            return true;
+        }
+        if (Date.now() > startTime + timeout) {
+            stopViteServer();
+            throw new Error('waited too long for port: ' + port);
+        }
+        await sleep(50);
+        return await recursiveWaitForPort();
+    }
+    return await recursiveWaitForPort();
+}

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

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

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

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

package/dist/esm/src/feature/internal/evaluateWithRetryAndTimeout.js

@@ -0,0 +1,29 @@
+import sleep from '../../shared/sleep.js';
+export default async function evaluateWithRetryAndTimeout(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+argumentPassedToExpect, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+evaluationFn, opts) {
+    const timeout = opts.timeout || 4000;
+    const interval = opts.interval || 10;
+    const startTime = Date.now();
+    async function intervalCb() {
+        const res = await evaluationFn(argumentPassedToExpect);
+        const expired = Date.now() >= startTime + timeout;
+        if (res.pass) {
+            return {
+                message: () => (opts.successText ? opts.successText(res.actual) : 'Success'),
+                pass: true,
+            };
+        }
+        if (expired) {
+            return {
+                message: () => opts.failureText(res.actual),
+                pass: false,
+            };
+        }
+        await sleep(interval);
+        return await intervalCb();
+    }
+    return await intervalCb();
+}

package/dist/esm/src/feature/internal/evaluationFailure.js

@@ -0,0 +1,6 @@
+export default function evaluationFailure(actual) {
+    return {
+        pass: false,
+        actual,
+    };
+}

package/dist/esm/src/feature/internal/evaluationSuccess.js

@@ -0,0 +1,6 @@
+export default function evaluationSuccess(actual) {
+    return {
+        pass: true,
+        actual,
+    };
+}

package/dist/esm/src/feature/internal/getAllTextContentFromPage.js

@@ -0,0 +1,19 @@
+export default async function getAllTextContentFromPage(page) {
+    // Evaluate and extract all text content on the page
+    const allText = await page.evaluate(() => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        const elements = document.body.querySelectorAll('*');
+        const textContentArray = [];
+        elements.forEach(element => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            if (element.textContent.trim() !== '') {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                textContentArray.push(element.innerText.trim());
+            }
+        });
+        return textContentArray.join(' ');
+    });
+    return allText;
+}

package/dist/esm/src/feature/internal/isPuppeteerPage.js

@@ -0,0 +1,3 @@
+export default function isPuppeteerPage(page) {
+    return typeof page === 'object' && page !== null && !!page.mouse;
+}

package/dist/esm/src/feature/internal/matchFailure.js

@@ -0,0 +1,6 @@
+export default function matchFailure(message) {
+    return {
+        pass: false,
+        message: (expected) => (typeof message === 'string' ? message : message(expected)),
+    };
+}

package/dist/esm/src/feature/internal/matchSuccess.js

@@ -0,0 +1,6 @@
+export default function matchSuccess(message) {
+    return {
+        pass: true,
+        message: (expected) => (typeof message === 'string' ? message : message(expected)),
+    };
+}

package/dist/esm/src/feature/internal/requirePuppeteerPage.js

@@ -0,0 +1,6 @@
+import isPuppeteerPage from './isPuppeteerPage.js';
+export default function requirePuppeteerPage(argumentPassedToExpect) {
+    if (!isPuppeteerPage(argumentPassedToExpect)) {
+        throw new Error('Must pass a puppeteer page to expect when calling toMatchTextContent');
+    }
+}

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

@@ -0,0 +1,23 @@
+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);
+        return {
+            pass: isCheckedNow,
+            actual: expectedText,
+        };
+    }, {
+        successText: r => `Expected page to have checkable checkbox with text: "${expectedText}"`,
+        failureText: r => `Expected page not to have checkable checkbox with text: "${expectedText}"`,
+    });
+}

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

@@ -0,0 +1,25 @@
+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;
+        }
+        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}"`,
+    });
+}

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

@@ -0,0 +1,25 @@
+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;
+        }
+        return {
+            pass: true,
+            actual: expectedText,
+        };
+    }, {
+        successText: () => `Expected page to have clickable button with text: "${expectedText}"`,
+        failureText: () => `Expected page not to have clickable button with text: "${expectedText}"`,
+    });
+}

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

@@ -0,0 +1,25 @@
+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;
+        }
+        return {
+            pass: true,
+            actual: expectedText,
+        };
+    }, {
+        successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
+        failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
+    });
+}

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

@@ -0,0 +1,25 @@
+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;
+        }
+        return {
+            pass: true,
+            actual: cssSelector,
+        };
+    }, {
+        successText: () => `Expected page to have clickable selector with text: "${cssSelector}"`,
+        failureText: () => `Expected page not to have clickable selector with text: "${cssSelector}"`,
+    });
+}

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

@@ -0,0 +1,21 @@
+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);
+        }
+        return {
+            pass: true,
+            actual: text,
+        };
+    }, {
+        successText: () => `Expected page to have clickable link with text: "${text}"`,
+        failureText: () => `Expected page not to have clickable link with text: "${text}"`,
+    });
+}

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

@@ -0,0 +1,19 @@
+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}"`);
+        const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
+        return {
+            pass: isChecked,
+            actual: expectedText,
+        };
+    }, {
+        successText: r => `Expected page to have checked checkbox with text: "${expectedText}"`,
+        failureText: r => `Expected page not to have checked checkbox with text: "${expectedText}"`,
+    });
+}

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

@@ -0,0 +1,25 @@
+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;
+        }
+        return {
+            pass: !!el,
+            actual: expectedText,
+        };
+    }, {
+        successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
+        failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
+    });
+}

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

@@ -0,0 +1,15 @@
+import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
+import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
+export default async function toHavePath(page, expectedPath) {
+    requirePuppeteerPage(page);
+    return await evaluateWithRetryAndTimeout(page, async () => {
+        const pathname = new URL(page.url()).pathname;
+        return {
+            pass: pathname === expectedPath,
+            actual: expectedPath,
+        };
+    }, {
+        successText: () => `Expected page to have path: "${expectedPath}"`,
+        failureText: () => `Expected page not to have path: "${expectedPath}"`,
+    });
+}

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

@@ -0,0 +1,14 @@
+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);
+        return {
+            pass: !!(await page.$(expectedSelector)),
+            actual: expectedSelector,
+        };
+    }, {
+        successText: r => `Expected ${r} to have selector: ${expectedSelector}`,
+        failureText: r => `Expected ${r} not to have selector: ${expectedSelector}`,
+    });
+}

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

@@ -0,0 +1,19 @@
+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}"`);
+        const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox);
+        return {
+            pass: !isChecked,
+            actual: expectedText,
+        };
+    }, {
+        successText: r => `Expected page to have unchecked checkbox with text: "${expectedText}"`,
+        failureText: r => `Expected page not to have unchecked checkbox with text: "${expectedText}"`,
+    });
+}

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

@@ -0,0 +1,14 @@
+import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js';
+import requirePuppeteerPage from '../internal/requirePuppeteerPage.js';
+export default async function toHaveUrl(page, expectedUrl) {
+    requirePuppeteerPage(page);
+    return await evaluateWithRetryAndTimeout(page, async () => {
+        return {
+            pass: page.url() === expectedUrl,
+            actual: expectedUrl,
+        };
+    }, {
+        successText: () => `Expected page to have path: "${expectedUrl}"`,
+        failureText: () => `Expected page not to have path: "${expectedUrl}"`,
+    });
+}

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

@@ -0,0 +1,16 @@
+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);
+        return {
+            pass: actual.includes(expected),
+            actual,
+        };
+    }, {
+        successText: r => `Expected ${r} to match text ${expected}`,
+        failureText: r => `Expected ${r} not to match text ${expected}`,
+    });
+}