@rvoh/psychic-spec-helpers 0.6.1 → 0.7.1

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

@@ -11,5 +11,17 @@ describe('check', () => {
             await check('not found checkbox', { timeout: 500 });
         }).rejects.toThrow();
     });
+    it('fails when the label points to an invalid input', async () => {
+        await check('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await check('My invalid label pointer checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
+    it('fails when the label points to a label with a missing htmlFor statement', async () => {
+        await check('My checkbox', { timeout: 500 });
+        await expect(async () => {
+            await check('My missing htmlFor checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
 });
 export {};

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

@@ -9,6 +9,19 @@ describe('uncheck', () => {
         inputValue = await page.$eval('#my-checkbox', input => input.checked).catch(() => null);
         expect(inputValue).toBe(false);
     });
+    it('succeeds when label has nested elements with text matching', async () => {
+        await check('My other checkbox');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        let inputValue = await page
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+            .$eval('#my-other-checkbox', input => input.checked)
+            .catch(() => null);
+        expect(inputValue).toBe(true);
+        await uncheck('My other 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-other-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 });
@@ -16,5 +29,15 @@ describe('uncheck', () => {
             await uncheck('not found checkbox', { timeout: 500 });
         }).rejects.toThrow();
     });
+    it('fails when the selector is found, but it is not already checked', async () => {
+        await check('My checkbox');
+        await uncheck('My checkbox', { timeout: 500 });
+        // 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(false);
+        await expect(async () => {
+            await uncheck('My checkbox', { timeout: 500 });
+        }).rejects.toThrow();
+    });
 });
 export {};

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

@@ -0,0 +1,29 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecRequest#delete', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a delete request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        await request.delete('/users/{id}', 204, {
+            id: user.id,
+            headers: {
+                hello: 'world',
+            },
+        });
+        expect(await User.count()).toEqual(0);
+    });
+    context('without params', () => {
+        it('issues a delete request to a controller endpoint, passing when the status matches', async () => {
+            await request.delete('/user', 204, {
+                headers: {
+                    hello: 'world',
+                },
+            });
+            await request.delete('/user', 204);
+        });
+    });
+});

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

@@ -0,0 +1,35 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecRequest#get', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        const res = await request.get('/users', 200, { headers: { hello: 'world' } });
+        expect(res.body).toEqual([{ id: user.id, email: 'abc@def' }]);
+    });
+    context('with params', () => {
+        it('succeeds', async () => {
+            const user = await User.create({ email: 'abc@def' });
+            const res = await request.get('/users/{id}', 200, {
+                id: user.id,
+                headers: { hello: 'world' },
+            });
+            expect(res.body).toEqual({ id: user.id, email: 'abc@def' });
+        });
+    });
+    context('query params', () => {
+        it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+            await User.create({ email: 'other@user' });
+            const user = await User.create({ email: 'abc@def' });
+            const res = await request.get('/users', 200, {
+                query: { search: 'abc' },
+                headers: { hello: 'world' },
+            });
+            expect(res.body).toEqual([{ id: user.id, email: 'abc@def' }]);
+        });
+    });
+});

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

@@ -0,0 +1,32 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecRequest#patch', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a patch request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        await request.patch('/users/{id}', 204, {
+            id: user.id,
+            data: {
+                email: 'how@yadoin',
+            },
+            headers: {
+                hello: 'world',
+            },
+        });
+        await User.findOrFailBy({ email: 'how@yadoin' });
+    });
+    context('without params', () => {
+        it('issues a patch request to a controller endpoint, passing when the status matches', async () => {
+            await request.patch('/user', 204, {
+                headers: {
+                    hello: 'world',
+                },
+            });
+            await request.patch('/user', 204);
+        });
+    });
+});

package/dist/esm/spec/unit/OpenapiSpecRequest/post.spec.js

@@ -0,0 +1,30 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecRequest#post', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+        await request.post('/users', 201, {
+            data: {
+                email: 'how@yadoin',
+            },
+            headers: {
+                hello: 'world',
+            },
+        });
+        await User.findOrFailBy({ email: 'how@yadoin' });
+    });
+    context('without params', () => {
+        it('issues a post request to a controller endpoint, passing when the status matches', async () => {
+            await request.post('/user', 201, {
+                headers: {
+                    hello: 'world',
+                },
+            });
+            await request.post('/user', 201);
+        });
+    });
+});

package/dist/esm/spec/unit/OpenapiSpecRequest/put.spec.js

@@ -0,0 +1,32 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecRequest#put', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a patch request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        await request.put('/users/{id}/update-put', 204, {
+            id: user.id,
+            data: {
+                email: 'how@yadoin',
+            },
+            headers: {
+                hello: 'world',
+            },
+        });
+        await User.findOrFailBy({ email: 'how@yadoin' });
+    });
+    context('without params', () => {
+        it('issues a put request to a controller endpoint, passing when the status matches', async () => {
+            await request.put('/user/update-put', 204, {
+                headers: {
+                    hello: 'world',
+                },
+            });
+            await request.put('/user/update-put', 204);
+        });
+    });
+});

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

@@ -0,0 +1,17 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecSession#delete', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a delete request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        const session = await request.session('get', '/users', 200);
+        await session.delete('/users/{id}', 204, {
+            id: user.id,
+        });
+        expect(await User.count()).toEqual(0);
+    });
+});

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

@@ -0,0 +1,24 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecSession#get', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        const session = await request.session('get', '/users', 200);
+        const res = await session.get('/users', 200);
+        expect(res.body).toEqual([{ id: user.id, email: 'abc@def' }]);
+    });
+    context('query params', () => {
+        it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+            await User.create({ email: 'other@user' });
+            const user = await User.create({ email: 'abc@def' });
+            const session = await request.session('get', '/users', 200);
+            const res = await session.get('/users', 200, { query: { search: 'abc' } });
+            expect(res.body).toEqual([{ id: user.id, email: 'abc@def' }]);
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecSession#put', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a patch request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        const session = await request.session('get', '/users', 200);
+        await session.patch('/users/{id}', 204, {
+            id: user.id,
+            data: {
+                email: 'how@yadoin',
+            },
+        });
+        await User.findOrFailBy({ email: 'how@yadoin' });
+    });
+});

package/dist/esm/spec/unit/OpenapiSpecSession/post.spec.js

@@ -0,0 +1,18 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecSession#post', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a get request to a controller endpoint, passing when the status matches', async () => {
+        const session = await request.session('get', '/users', 200);
+        await session.post('/users', 201, {
+            data: {
+                email: 'how@yadoin',
+            },
+        });
+        await User.findOrFailBy({ email: 'how@yadoin' });
+    });
+});

package/dist/esm/spec/unit/OpenapiSpecSession/put.spec.js

@@ -0,0 +1,20 @@
+import { PsychicServer } from '@rvoh/psychic';
+import { OpenapiSpecRequest } from '../../../src/unit/OpenapiSpecRequest.js';
+import User from '../../../test-app/src/app/models/User.js';
+const request = new OpenapiSpecRequest();
+describe('OpenapiSpecSession#put', () => {
+    beforeEach(async () => {
+        await request.init(PsychicServer);
+    });
+    it('issues a patch request to a controller endpoint, passing when the status matches', async () => {
+        const user = await User.create({ email: 'abc@def' });
+        const session = await request.session('get', '/users', 200);
+        await session.put('/users/{id}/update-put', 204, {
+            id: user.id,
+            data: {
+                email: 'how@yadoin',
+            },
+        });
+        await User.findOrFailBy({ email: 'how@yadoin' });
+    });
+});

package/dist/esm/spec/unit/specRequest/helpers/fillOpenapiUrlParams.spec.js

@@ -0,0 +1,11 @@
+import fillOpenapiParams from '../../../../src/unit/helpers/fillOpenapiParams.js';
+describe('fillOpenapiUrlParams', () => {
+    it('pushes params into a route', () => {
+        expect(fillOpenapiParams('/users/{id}/pets/{petId}/posts/{postId}', {
+            id: 1,
+            petId: 2,
+            postId: 3,
+            otherId: 4,
+        })).toEqual('/users/1/pets/2/posts/3');
+    });
+});

package/dist/esm/src/feature/error-messages/emptyForAttribute.js

@@ -0,0 +1,12 @@
+export default function emptyForAttribute() {
+    return `
+When using our uncheck helpers, we expect you to have the correct semantic layout for a checkbox on your page.
+this includes the following:
+
+1.) a label element with matching text, with a "for" attribute set (or htmlFor, when using react)
+2.) an input with type="checkbox" which has an id that matches the corresponding for tag on the label
+
+We were able to find a label matching the text you gave us, but the for attribute found on it
+was blank. Make sure to add a for attribute, and point it to the id of your corresponding checkbox
+`;
+}

package/dist/esm/src/feature/error-messages/missingInputToMatchForAttribute.js

@@ -0,0 +1,10 @@
+export default function missingForAttribute(forAttributeValue) {
+    return `
+Expected to find an input element matching the "for" attribute on your label, but we could not locate that input element.
+
+for attribute found: "${forAttributeValue}"
+
+Make sure you have an input element with an id matching "${forAttributeValue}", otherwise this label
+will not be able to be properly associated with the corresponding input.
+`;
+}

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

@@ -0,0 +1,26 @@
+export default async function captureAttributeFromClosestElementWithType(cssSelector, type, attribute) {
+    const el = await page.waitForSelector(cssSelector, { timeout: 3000 });
+    const attributeValue = (await el.evaluate((element, type, attribute) => {
+        // Traverse up the DOM tree to find the closest parent label element
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        let currentElement = element;
+        let attrVal = null;
+        let millisDrift = 0;
+        const startMillis = Date.now();
+        while (!attrVal && currentElement && millisDrift < 3000) {
+            const currMillis = Date.now();
+            millisDrift = currMillis - startMillis;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (currentElement.tagName === type.toUpperCase()) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                attrVal = Array.from(currentElement.attributes).find(attr => attr.name === attribute)?.['value'];
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+                currentElement = currentElement.parentElement;
+            }
+        }
+        return attrVal;
+    }, type, attribute));
+    return attributeValue;
+}

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

@@ -1,11 +1,31 @@
 import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js';
+import emptyForAttribute from '../error-messages/emptyForAttribute.js';
+import missingInputToMatchForAttribute from '../error-messages/missingInputToMatchForAttribute.js';
+import captureAttributeFromClosestElementWithType from '../internal/captureAttributeFromClosestElementWithType.js';
 export default async function toCheck(page, expectedText, opts) {
     const failure = {
         pass: false,
         message: () => `Expected page to have checkable element with text: "${expectedText}"`,
     };
+    const labelSelector = `label::-p-text("${expectedText}")`;
     try {
-        await expect(page).toClickSelector(`label::-p-text("${expectedText}")`, applyDefaultWaitForOpts(opts));
+        const forAttributeValue = await captureAttributeFromClosestElementWithType(labelSelector, 'label', 'for');
+        if (!forAttributeValue) {
+            return {
+                pass: false,
+                message: () => emptyForAttribute(),
+            };
+        }
+        try {
+            await page.waitForSelector(`#${forAttributeValue}`, applyDefaultWaitForOpts(opts));
+        }
+        catch {
+            return {
+                pass: false,
+                message: () => missingInputToMatchForAttribute(forAttributeValue),
+            };
+        }
+        await expect(page).toClickSelector(labelSelector, applyDefaultWaitForOpts(opts));
         return {
             pass: true,
             message: () => {

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

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

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

@@ -1,10 +1,28 @@
 import applyDefaultWaitForOpts from '../helpers/applyDefaultWaitForOpts.js';
+import emptyForAttribute from '../error-messages/emptyForAttribute.js';
+import missingInputToMatchForAttribute from '../error-messages/missingInputToMatchForAttribute.js';
+import captureAttributeFromClosestElementWithType from '../internal/captureAttributeFromClosestElementWithType.js';
 export default async function toUncheck(page, expectedText, opts) {
     try {
         const labelSelector = `label::-p-text("${expectedText}")`;
-        // eslint-disable-next-line
-        const forAttributeValue = await page.$eval(labelSelector, label => label.getAttribute('for'));
-        const inputElement = await page.waitForSelector(`#${forAttributeValue}`, applyDefaultWaitForOpts(opts));
+        const forAttributeValue = await captureAttributeFromClosestElementWithType(labelSelector, 'label', 'for');
+        if (!forAttributeValue) {
+            return {
+                pass: false,
+                message: () => emptyForAttribute(),
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let inputElement = null;
+        try {
+            inputElement = await page.waitForSelector(`#${forAttributeValue}`, applyDefaultWaitForOpts(opts));
+        }
+        catch {
+            return {
+                pass: false,
+                message: () => missingInputToMatchForAttribute(forAttributeValue),
+            };
+        }
         // eslint-disable-next-line
         const isChecked = await page.evaluate(checkbox => checkbox.checked, inputElement);
         if (!isChecked)

package/dist/esm/src/index.js

@@ -1,6 +1,8 @@
 // unit spec helpers
 export { default as specRequest } from './unit/SpecRequest.js';
 export { default as createPsychicServer } from './unit/createPsychicServer.js';
+export { OpenapiSpecRequest } from './unit/OpenapiSpecRequest.js';
+export { OpenapiSpecSession } from './unit/OpenapiSpecSession.js';
 export { SpecRequest } from './unit/SpecRequest.js';
 export { SpecSession } from './unit/SpecSession.js';
 // feature spec helpers

package/dist/esm/src/unit/OpenapiSpecRequest.js

@@ -0,0 +1,103 @@
+import supertest from 'supertest';
+import { createPsychicServer } from '../index.js';
+import fillOpenapiParams from './helpers/fillOpenapiParams.js';
+import { OpenapiSpecSession } from './OpenapiSpecSession.js';
+import supersession from './supersession.js';
+export class OpenapiSpecRequest {
+    // eslint-disable-next-line
+    PsychicServer;
+    // eslint-disable-next-line
+    server;
+    // final
+    async get(uri, expectedStatus, opts) {
+        return (await this.makeRequest('get', fillOpenapiParams(uri, (opts || {})), expectedStatus, opts));
+    }
+    // final
+    async post(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('post', uri, expectedStatus, opts);
+    }
+    // final
+    async put(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('put', fillOpenapiParams(uri, opts || {}), expectedStatus, opts);
+    }
+    // final
+    async patch(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('patch', fillOpenapiParams(uri, opts), expectedStatus, opts);
+    }
+    // final
+    async delete(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('delete', fillOpenapiParams(uri, opts), expectedStatus, opts);
+    }
+    // eslint-disable-next-line
+    async init(PsychicServer) {
+        // eslint-disable-next-line
+        this.PsychicServer = PsychicServer;
+        this.server ||= await createPsychicServer(PsychicServer);
+    }
+    // final
+    async session(httpMethod, uri, expectedStatus, opts = {}) {
+        const postOpts = opts;
+        const getOpts = opts;
+        uri = fillOpenapiParams(uri, (opts || {}));
+        return await new Promise((accept, reject) => {
+            createPsychicServer(this.PsychicServer)
+                .then(server => {
+                const session = supersession(server);
+                // supersession is borrowed from a non-typescript repo, which
+                // does not have strong types around http methods, so we need to any cast
+                let req = session[(httpMethod || 'post')](`/${uri.replace(/^\//, '')}`);
+                if (postOpts.data) {
+                    req = req.send(postOpts.data);
+                }
+                req
+                    .expect(expectedStatus)
+                    .query(getOpts.query || {})
+                    .set(postOpts.headers || {})
+                    .end((err) => {
+                    if (err)
+                        return reject(err);
+                    return accept(new OpenapiSpecSession(session));
+                });
+            })
+                .catch(err => {
+                throw err;
+            });
+        });
+    }
+    async makeRequest(method, uri, expectedStatus, opts = {}) {
+        // TODO: find out why this is necessary. Currently, without initializing the server
+        // at the beginning of the specs, supertest is unable to use our server to handle requests.
+        // it gives the appearance of being an issue with a runaway promise (i.e. missing await)
+        // but I can't find it anywhere, so I am putting this init method in as a temporary fix.
+        if (!this.server)
+            throw new Error(`
+  ERROR:
+    When making use of the send spec helper, you must first call "await specRequest.init(PsychicServer)"
+    from a beforEach hook at the root of your specs.
+`);
+        if (expectedStatus === 500) {
+            process.env.PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR = '1';
+        }
+        // eslint-disable-next-line
+        const req = supertest.agent(this.server.expressApp);
+        let request = req[method](`/${uri.replace(/^\//, '')}`);
+        if (opts.headers)
+            request = request.set(opts.headers);
+        if (opts.query)
+            request = request.query(opts.query);
+        if (method !== 'get')
+            request = request.send(opts.data);
+        try {
+            const res = await request.expect(expectedStatus);
+            process.env.PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR = undefined;
+            return res;
+        }
+        catch (err) {
+            // without manually console logging, you get no stack trace here
+            console.error(err);
+            console.trace();
+            process.env.PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR = undefined;
+            throw err;
+        }
+    }
+}

package/dist/esm/src/unit/OpenapiSpecSession.js

@@ -0,0 +1,54 @@
+import fillOpenapiParams from './helpers/fillOpenapiParams.js';
+// like SpecRequest, but meant to be bound to an instance
+// of supersession, enabling chained requests to collect cookies
+export class OpenapiSpecSession {
+    _session;
+    constructor(_session) {
+        this._session = _session;
+    }
+    // final
+    async get(uri, expectedStatus, opts) {
+        return (await this.makeRequest('get', fillOpenapiParams(uri, (opts || {})), expectedStatus, opts));
+    }
+    // final
+    async post(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('post', uri, expectedStatus, opts);
+    }
+    // final
+    async put(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('put', fillOpenapiParams(uri, opts || {}), expectedStatus, opts);
+    }
+    // final
+    async patch(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('patch', fillOpenapiParams(uri, opts), expectedStatus, opts);
+    }
+    // final
+    async delete(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('delete', fillOpenapiParams(uri, opts), expectedStatus, opts);
+    }
+    async makeRequest(method, uri, expectedStatus, opts = {}) {
+        if (expectedStatus === 500) {
+            process.env.PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR = '1';
+        }
+        const req = this._session;
+        let request = req[method](`/${uri.replace(/^\//, '')}`);
+        if (opts.headers)
+            request = request.set(opts.headers);
+        if (opts.query)
+            request = request.query(opts.query);
+        if (method !== 'get')
+            request = request.send(opts.data);
+        try {
+            const res = await request.expect(expectedStatus);
+            process.env.PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR = undefined;
+            return res;
+        }
+        catch (err) {
+            // without manually console logging, you get no stack trace here
+            console.error(err);
+            console.trace();
+            process.env.PSYCHIC_EXPECTING_INTERNAL_SERVER_ERROR = undefined;
+            throw err;
+        }
+    }
+}

package/dist/esm/src/unit/helpers/fillOpenapiParams.js

@@ -0,0 +1,8 @@
+export default function fillOpenapiParams(url, params) {
+    const matches = url.matchAll(/\{([^}]*)}/g);
+    for (const match of matches) {
+        const segment = match[1];
+        url = url.replace(`{${segment}}`, params[segment]);
+    }
+    return url;
+}

package/dist/esm/src/unit/helpers/openapiTypeHelpers.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/unit/helpers/typeHelpers.js

@@ -0,0 +1 @@
+export {};