@rvoh/psychic-spec-helpers 0.4.4 → 0.5.0

package/client/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

package/dist/esm/spec/features/check.spec.js

@@ -0,0 +1,15 @@
+describe('check', () => {
+    it('succeeds when label for checkbox is found', async () => {
+        await check('My checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        const inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
+        expect(inputValue).toBe(true);
+    });
+    it('fails when the selector is not found', async () => {
+        await check('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await check('not found checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/click.spec.js

@@ -0,0 +1,12 @@
+describe('click', () => {
+    it('succeeds when the selector is found', async () => {
+        await click('My div');
+    });
+    it('fails when the selector is not found', async () => {
+        await click('My div', { timeout: 500 });
+        await expect(async () => {
+            await click('Not found div', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/clickButton.spec.js

@@ -0,0 +1,12 @@
+describe('clickButton', () => {
+    it('succeeds when the selector is found', async () => {
+        await clickButton('My button');
+    });
+    it('fails when the selector is not found', async () => {
+        await clickButton('My button', { timeout: 500 });
+        await expect(async () => {
+            await clickButton('Not found button', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/clickLink.spec.js

@@ -0,0 +1,12 @@
+describe('clickLink', () => {
+    it('succeeds when the selector is found', async () => {
+        await clickLink('My link');
+    });
+    it('fails when the selector is not found', async () => {
+        await clickLink('My link', { timeout: 500 });
+        await expect(async () => {
+            await clickLink('Not found link', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/clickSelector.spec.js

@@ -0,0 +1,12 @@
+describe('clickSelector', () => {
+    it('succeeds when the selector is found', async () => {
+        await clickSelector('#my-button');
+    });
+    it('fails when the selector is not found', async () => {
+        await clickSelector('#my-button', { timeout: 500 });
+        await expect(async () => {
+            await clickSelector('#not-found', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/fillIn.spec.js

@@ -0,0 +1,15 @@
+describe('fillIn', () => {
+    it('succeeds when the input is fillable', async () => {
+        await fillIn('#my-input', 'hello');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        const inputValue = await page.$eval('#my-input', input => input.value).catch(() => null);
+        expect(inputValue).toEqual('hello');
+    });
+    it('fails when the selector is not found', async () => {
+        await fillIn('#my-input', 'hello world', { timeout: 500 });
+        await expect(async () => {
+            await fillIn('#not-found-input', 'hello world', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/helpers/getPage.js

@@ -0,0 +1,10 @@
+import { launchPage } from '../../../src/index.js';
+let page;
+export default async function getPage(opts) {
+    if (!page) {
+        page = await launchPage({ headless: process.env.HEADLESS !== '0', timeout: 20000, ...opts });
+        // set the browser dimensions prior to running specs
+        await page.setViewport({ width: 1200, height: 800 });
+    }
+    return page;
+}

package/dist/esm/spec/features/matchers/toCheck.spec.js

@@ -0,0 +1,15 @@
+describe('toCheck', () => {
+    it('succeeds when label for checkbox is found', async () => {
+        await expect(page).toCheck('My checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        const inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
+        expect(inputValue).toBe(true);
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toCheck('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toCheck('not found checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toClick.spec.js

@@ -0,0 +1,13 @@
+describe('toClick', () => {
+    it('succeeds when the selector is found', async () => {
+        await expect(page).toClick('My div');
+    });
+    it('fails when the selector is not found', async () => {
+        await click('My div', { timeout: 500 });
+        await expect(page).toClick('My div', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toClick('Not found div', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toClickButton.spec.js

@@ -0,0 +1,12 @@
+describe('toClickButton', () => {
+    it('succeeds when the selector is found', async () => {
+        await expect(page).toClickButton('My button');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toClickButton('My button', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toClickButton('Not found button', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toClickLink.spec.js

@@ -0,0 +1,12 @@
+describe('clickLink', () => {
+    it('succeeds when the selector is found', async () => {
+        await expect(page).toClickLink('My link');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toClickLink('My link', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toClickLink('Not found link', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toClickSelector.spec.js

@@ -0,0 +1,12 @@
+describe('toClickSelector', () => {
+    it('succeeds when the selector is found', async () => {
+        await expect(page).toClickSelector('#my-button');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toClickSelector('#my-button', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toClickSelector('#not-found', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toFill.spec.js

@@ -0,0 +1,15 @@
+describe('toFill', () => {
+    it('succeeds when the input is fillable', async () => {
+        await expect(page).toFill('#my-input', 'hello');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        const inputValue = await page.$eval('#my-input', input => input.value).catch(() => null);
+        expect(inputValue).toEqual('hello');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toFill('#my-input', 'hello world', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toFill('#not-found-input', 'hello world', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toHaveChecked.spec.js

@@ -0,0 +1,13 @@
+describe('toHaveChecked', () => {
+    it('succeeds when label for checkbox is found', async () => {
+        await check('My checkbox');
+        await expect(page).toHaveChecked('My checkbox');
+    });
+    it('fails when the selector is not found', async () => {
+        await check('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toHaveChecked('not found checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toHaveLink.spec.js

@@ -0,0 +1,12 @@
+describe('toHaveLink', () => {
+    it('succeeds when link with text is found', async () => {
+        await expect(page).toHaveLink('My link');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toHaveLink('My link', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toHaveLink('not found link', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toHavePath.spec.js

@@ -0,0 +1,12 @@
+describe('toHavePath', () => {
+    it('succeeds when the path is correct', async () => {
+        await expect(page).toHavePath('/');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toHavePath('/', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toHavePath('/not-found', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toHaveSelector.spec.js

@@ -0,0 +1,12 @@
+describe('toHavePath', () => {
+    it('succeeds when the path is correct', async () => {
+        await expect(page).toHaveSelector('#my-button');
+    });
+    it('fails when the selector is not found', async () => {
+        await expect(page).toHaveSelector('#my-button', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toHaveSelector('#not-found-button', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toHaveUnchecked.spec.js

@@ -0,0 +1,19 @@
+describe('toHaveUnchecked', () => {
+    it('succeeds when the input is unchecked', async () => {
+        await expect(page).toHaveUnchecked('My checkbox');
+    });
+    it('fails when the input is checked', async () => {
+        await expect(page).toHaveUnchecked('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await check('My checkbox');
+            await expect(page).toHaveUnchecked('My checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+    it('fails when the input is not found', async () => {
+        await check('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toHaveUnchecked('not found checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toHaveUrl.spec.js

@@ -0,0 +1,13 @@
+describe('toHaveUrl', () => {
+    it('succeeds when the page matches the url', async () => {
+        await expect(page).toHaveUrl('http://localhost:3000/');
+        await expect(page).toHaveUrl('http://localhost:3000');
+    });
+    it('fails when the page does not match the url', async () => {
+        await expect(page).toHaveUrl('http://localhost:3000/', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toHaveUrl('http://localhost:3000/not-here', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toMatchTextContent.spec.js

@@ -0,0 +1,12 @@
+describe('toMatchTextContent', () => {
+    it('succeeds when the page matches the content', async () => {
+        await expect(page).toMatchTextContent('My div');
+    });
+    it('fails when the page does not match the content', async () => {
+        await expect(page).toMatchTextContent('My div', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toMatchTextContent('not found div', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toNotMatchSelector.spec.js

@@ -0,0 +1,12 @@
+describe('toNotHaveSelector', () => {
+    it('succeeds when the page does not match the selector', async () => {
+        await expect(page).toNotHaveSelector('#not-found-selector', { timeout: 300 });
+    });
+    it('fails when the page does match the selector', async () => {
+        await expect(page).toNotHaveSelector('#not-found-selector', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toNotHaveSelector('#my-div', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toNotMatchTextContent.spec.js

@@ -0,0 +1,12 @@
+describe('toNotMatchTextContent', () => {
+    it('succeeds when the page does not match the content', async () => {
+        await expect(page).toNotMatchTextContent('not found div', { timeout: 300 });
+    });
+    it('fails when the page does match the content', async () => {
+        await expect(page).toNotMatchTextContent('not found div', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toNotMatchTextContent('My div', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/matchers/toUncheck.spec.js

@@ -0,0 +1,20 @@
+describe('uncheck', () => {
+    it('succeeds when label for checkbox is found', async () => {
+        await check('My checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        let inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
+        expect(inputValue).toBe(true);
+        await expect(page).toUncheck('My checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
+        expect(inputValue).toBe(false);
+    });
+    it('fails when the selector is not found', async () => {
+        await check('My checkbox');
+        await expect(page).toUncheck('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await expect(page).toUncheck('not found checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/setup/globalSetup.js

@@ -0,0 +1,8 @@
+import '../../../test-app/src/conf/loadEnv.js';
+import { PsychicDevtools } from '@rvoh/psychic';
+export async function setup() {
+    await PsychicDevtools.launchDevServer('client', { port: 3000, cmd: 'yarn client:fspec' });
+}
+export function teardown() {
+    PsychicDevtools.stopDevServers();
+}

package/dist/esm/spec/features/setup/hooks.js

@@ -0,0 +1,36 @@
+import { DreamApplication } from '@rvoh/dream';
+import { provideDreamViteMatchers, truncate } from '@rvoh/dream-spec-helpers';
+import { PsychicServer } from '@rvoh/psychic';
+import { providePuppeteerViteMatchers } from '../../../src/index.js';
+import initializePsychicApplication from '../../../test-app/src/cli/helpers/initializePsychicApplication.js';
+import getPage from '../helpers/getPage.js';
+provideDreamViteMatchers();
+providePuppeteerViteMatchers();
+global.context = describe;
+global.jest = vi;
+let server;
+beforeAll(async () => {
+    try {
+        await initializePsychicApplication();
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+    server = new PsychicServer();
+    await server.start(parseInt(process.env.DEV_SERVER_PORT || '7778'));
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    if (!global.page) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+        ;
+        global.page = await getPage();
+    }
+});
+beforeEach(async () => {
+    await truncate(DreamApplication);
+    await visit('/');
+    await expect(page).toMatchTextContent('My div');
+});
+afterAll(async () => {
+    await server.stop();
+});

package/dist/esm/spec/features/uncheck.spec.js

@@ -0,0 +1,20 @@
+describe('uncheck', () => {
+    it('succeeds when label for checkbox is found', async () => {
+        await check('My checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        let inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
+        expect(inputValue).toBe(true);
+        await uncheck('My checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
+        expect(inputValue).toBe(false);
+    });
+    it('fails when the selector is not found', async () => {
+        await check('My checkbox');
+        await uncheck('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await uncheck('not found checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+});
+export {};

package/dist/esm/spec/features/vite.config.js

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        dir: './spec/features',
+        globals: true,
+        setupFiles: ['luxon-jest-matchers', './spec/features/setup/hooks.js'],
+        fileParallelism: false,
+        maxConcurrency: 1,
+        maxWorkers: 1,
+        minWorkers: 1,
+        mockReset: true,
+        watch: false,
+        printConsoleTrace: true,
+        globalSetup: './spec/features/setup/globalSetup.js',
+    },
+});

package/dist/esm/spec/helpers/sleep.js

@@ -0,0 +1,7 @@
+export default async function sleep(ms) {
+    return await new Promise(accept => {
+        setTimeout(() => {
+            accept(undefined);
+        }, ms);
+    });
+}

package/dist/esm/spec/unit/setup/globalSetup.js

@@ -0,0 +1,3 @@
+import '../../../test-app/src/conf/global.js';
+export async function setup() { }
+export async function teardown() { }

package/dist/esm/spec/unit/setup/hooks.js

@@ -0,0 +1,16 @@
+import { DreamApplication } from '@rvoh/dream';
+import { provideDreamViteMatchers, truncate } from '@rvoh/dream-spec-helpers';
+import initializePsychicApplication from '../../../test-app/src/cli/helpers/initializePsychicApplication.js';
+provideDreamViteMatchers();
+global.context = describe;
+global.jest = vi;
+beforeEach(async () => {
+    try {
+        await initializePsychicApplication();
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    await truncate(DreamApplication);
+});

package/dist/esm/spec/unit/specRequest/delete.spec.js

@@ -0,0 +1,45 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { specRequest as request } from '../../../src/index.js';
+describe('specRequest#delete', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a delete request to a controller endpoint, passing when the status matches', async () => {
+        const res = await request.delete(`/spec-request/delete-test`, 200, {
+            data: {
+                a: 'a',
+                b: 'b',
+            },
+            headers: {
+                headerA: 'A',
+                headerB: 'B',
+            },
+        });
+        expect(res.body).toEqual({
+            body: { a: 'a', b: 'b' },
+            headers: expect.objectContaining({
+                headera: 'A',
+                headerb: 'B',
+            }),
+        });
+    });
+    it('fails when the status does not match', async () => {
+        await expect(async () => {
+            await request.delete(`/spec-request/delete-test`, 201);
+        }).rejects.toThrow();
+    });
+    context('with an error status', () => {
+        it('passes when the error status is expected', async () => {
+            await request.delete(`/spec-request/delete-test`, 400, {
+                data: { throw400: true },
+            });
+        });
+        it('fails when the error status is not expected', async () => {
+            await expect(async () => {
+                await request.delete(`/spec-request/delete-test`, 200, {
+                    data: { throw400: true },
+                });
+            }).rejects.toThrow();
+        });
+    });
+});

package/dist/esm/spec/unit/specRequest/get.spec.js

@@ -0,0 +1,45 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { specRequest as request } from '../../../src/index.js';
+describe('specRequest#get', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+        const res = await request.get(`/spec-request/get-test`, 200, {
+            query: {
+                a: 'a',
+                b: 'b',
+            },
+            headers: {
+                headerA: 'A',
+                headerB: 'B',
+            },
+        });
+        expect(res.body).toEqual({
+            query: { a: 'a', b: 'b' },
+            headers: expect.objectContaining({
+                headera: 'A',
+                headerb: 'B',
+            }),
+        });
+    });
+    it('fails when the status does not match', async () => {
+        await expect(async () => {
+            await request.get(`/spec-request/get-test`, 201);
+        }).rejects.toThrow();
+    });
+    context('with an error status', () => {
+        it('passes when the error status is expected', async () => {
+            await request.get(`/spec-request/get-test`, 400, {
+                query: { throw400: true },
+            });
+        });
+        it('fails when the error status is not expected', async () => {
+            await expect(async () => {
+                await request.get(`/spec-request/get-test`, 200, {
+                    query: { throw400: true },
+                });
+            }).rejects.toThrow();
+        });
+    });
+});

package/dist/esm/spec/unit/specRequest/patch.spec.js

@@ -0,0 +1,45 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { specRequest as request } from '../../../src/index.js';
+describe('specRequest#patch', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a patch request to a controller endpoint, passing when the status matches', async () => {
+        const res = await request.patch(`/spec-request/patch-test`, 200, {
+            data: {
+                a: 'a',
+                b: 'b',
+            },
+            headers: {
+                headerA: 'A',
+                headerB: 'B',
+            },
+        });
+        expect(res.body).toEqual({
+            body: { a: 'a', b: 'b' },
+            headers: expect.objectContaining({
+                headera: 'A',
+                headerb: 'B',
+            }),
+        });
+    });
+    it('fails when the status does not match', async () => {
+        await expect(async () => {
+            await request.patch(`/spec-request/patch-test`, 201);
+        }).rejects.toThrow();
+    });
+    context('with an error status', () => {
+        it('passes when the error status is expected', async () => {
+            await request.patch(`/spec-request/patch-test`, 400, {
+                data: { throw400: true },
+            });
+        });
+        it('fails when the error status is not expected', async () => {
+            await expect(async () => {
+                await request.patch(`/spec-request/patch-test`, 200, {
+                    data: { throw400: true },
+                });
+            }).rejects.toThrow();
+        });
+    });
+});