@rvoh/psychic-spec-helpers 0.2.0

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

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

package/dist/esm/src/feature/matchers/toNotMatchTextContent.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 toNotMatchTextContent(argumentPassedToExpect, expected) {
+    return await evaluateWithRetryAndTimeout(argumentPassedToExpect, async () => {
+        requirePuppeteerPage(argumentPassedToExpect);
+        const actual = await getAllTextContentFromPage(argumentPassedToExpect);
+        return {
+            pass: !actual.includes(expected),
+            actual,
+        };
+    }, {
+        successText: r => `Expected ${r} not to match text ${expected}`,
+        failureText: r => `Expected ${r} to match text ${expected}`,
+    });
+}

package/dist/esm/src/feature/matchers/toUncheck.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 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);
+        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: !isCheckedNow,
+            actual: expectedText,
+        };
+    }, {
+        successText: r => `Expected page to have uncheckable checkbox with text: "${expectedText}"`,
+        failureText: r => `Expected page not to have uncheckable checkbox with text: "${expectedText}"`,
+    });
+}

package/dist/esm/src/index.js

@@ -0,0 +1,12 @@
+// unit spec helpers
+export { default as specRequest } from './unit/SpecRequest.js';
+export { default as createPsychicServer } from './unit/createPsychicServer.js';
+export { SpecRequest } from './unit/SpecRequest.js';
+export { SpecSession } from './unit/SpecSession.js';
+// feature spec helpers
+export { default as providePuppeteerViteMatchers } from './feature/helpers/providePuppeteerViteMatchers.js';
+export { default as launchBrowser } from './feature/helpers/launchBrowser.js';
+export { default as launchPage } from './feature/helpers/launchPage.js';
+export { default as launchViteServer, stopViteServer } from './feature/helpers/launchViteServer.js';
+export { default as visit } from './feature/helpers/visit.js';
+export default {};

package/dist/esm/src/shared/sleep.js

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

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

@@ -0,0 +1,89 @@
+import supertest from 'supertest';
+import { createPsychicServer } from '../index.js';
+import supersession from './supersession.js';
+import { SpecSession } from './SpecSession.js';
+export class SpecRequest {
+    PsychicServer;
+    server;
+    async get(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('get', uri, expectedStatus, opts);
+    }
+    async post(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('post', uri, expectedStatus, opts);
+    }
+    async put(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('put', uri, expectedStatus, opts);
+    }
+    async patch(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('patch', uri, expectedStatus, opts);
+    }
+    async delete(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('delete', uri, expectedStatus, opts);
+    }
+    async init(PsychicServer) {
+        this.PsychicServer = PsychicServer;
+        this.server ||= await createPsychicServer(PsychicServer);
+    }
+    async session(uri, credentials, expectedStatus, opts = {}) {
+        return await new Promise((accept, reject) => {
+            createPsychicServer(this.PsychicServer)
+                .then(server => {
+                const session = supersession(server);
+                session[(opts.httpMethod || 'post')](uri)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    .send(credentials)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    .expect(expectedStatus)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    .query(opts.query || {})
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    .set(opts.headers || {})
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    .end((err) => {
+                    if (err)
+                        return reject(err);
+                    return accept(new SpecSession(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';
+        }
+        const req = supertest.agent(this.server.expressApp);
+        let request = req[method](uri);
+        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;
+        }
+    }
+}
+export default new SpecRequest();

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

@@ -0,0 +1,48 @@
+// like SpecRequest, but meant to be bound to an instance
+// of supersession, enabling chained requests to collect cookies
+export class SpecSession {
+    _session;
+    constructor(_session) {
+        this._session = _session;
+    }
+    async get(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('get', uri, expectedStatus, opts);
+    }
+    async post(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('post', uri, expectedStatus, opts);
+    }
+    async put(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('put', uri, expectedStatus, opts);
+    }
+    async patch(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('patch', uri, expectedStatus, opts);
+    }
+    async delete(uri, expectedStatus, opts = {}) {
+        return await this.makeRequest('delete', uri, 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);
+        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/createPsychicServer.js

@@ -0,0 +1,8 @@
+const _server = undefined;
+export default async function createPsychicServer(PsychicServer) {
+    if (_server)
+        return _server;
+    const server = new PsychicServer();
+    await server.boot();
+    return server;
+}

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

@@ -0,0 +1,72 @@
+import { CookieAccessInfo as CookieAccess } from 'cookiejar';
+import http from 'http';
+import request from 'supertest';
+import URL from 'url';
+class Supersession {
+    options;
+    app;
+    agent;
+    url;
+    cookieAccess;
+    constructor(server, options = {}) {
+        this.options = options;
+        if (!server.expressApp) {
+            throw new Error('Supersession requires an `app`');
+        }
+        this.agent = request.agent(server.expressApp, options);
+        const app = http.createServer(server.expressApp);
+        const url = request.Test.prototype.serverAddress(app, '/');
+        this.app = app;
+        this.url = URL.parse(url);
+        this.reset();
+        // typescript is telling me I don't need to worry about options.helpers,
+        // but leaving this commented out in case we need to revisit
+        // if (this.options.helpers instanceof Object) {
+        //   assign(this, this.options.helpers)
+        // }
+    }
+    get cookies() {
+        return this.agent.jar.getCookies(this.cookieAccess);
+    }
+    reset() {
+        // Unset supertest-session options before forwarding options to superagent.
+        var agentOptions = {
+            ...this.options,
+            before: undefined,
+            cookieAccess: undefined,
+            destroy: undefined,
+            helpers: undefined,
+        };
+        this.agent = request.agent(this.app, agentOptions);
+        const domain = this.url.hostname;
+        const path = this.url.path;
+        const secure = 'https:' == this.url.protocol;
+        const script = false;
+        this.cookieAccess = CookieAccess(domain, path, secure, script);
+    }
+    destroy() {
+        if (this.options.destroy)
+            this.options.destroy.call(this);
+        this.reset();
+    }
+    request(method, route) {
+        var test = this.agent[method](route);
+        // typescript is telling me I don't need to worry about options.before,
+        // but leaving this commented out in case we need to revisit
+        // if (this.options.before) {
+        //   this.options.before.call(this, test)
+        // }
+        return test;
+    }
+}
+export const HttpMethods = ['get', 'post', 'put', 'patch', 'delete', 'options'];
+HttpMethods.forEach(function (m) {
+    ;
+    Supersession.prototype[m] = function () {
+        var args = [].slice.call(arguments);
+        return this.request.apply(this, [m].concat(args));
+    };
+});
+export default function supersession(server, config = {}) {
+    return new Supersession(server, config);
+}

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

@@ -0,0 +1,2 @@
+import puppeteer, { LaunchOptions } from 'puppeteer';
+export default function launchBrowser(opts?: LaunchOptions): Promise<puppeteer.Browser>;

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

@@ -0,0 +1,2 @@
+import { LaunchOptions } from 'puppeteer';
+export default function launchPage(opts?: LaunchOptions): Promise<import("puppeteer").Page>;

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

@@ -0,0 +1,6 @@
+export default function launchViteServer({ port, cmd, timeout, }?: {
+    port?: number;
+    cmd?: string;
+    timeout?: number;
+}): Promise<void>;
+export declare function stopViteServer(): void;

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

@@ -0,0 +1,5 @@
+export default function providePuppeteerViteMatchers(): void;
+export interface CustomMatcherResult {
+    pass: boolean;
+    message: (actual?: unknown) => string;
+}

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

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

package/dist/types/src/feature/internal/evaluateWithRetryAndTimeout.d.ts

@@ -0,0 +1,14 @@
+export default function evaluateWithRetryAndTimeout(argumentPassedToExpect: any, evaluationFn: (a: any) => ExpectToEvaluateReturnType | Promise<ExpectToEvaluateReturnType>, opts: ExpectToEvaluateOpts): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;
+export type ExpectToEvaluateReturnType = {
+    pass: boolean;
+    actual: any;
+};
+export interface ExpectToEvaluateOpts {
+    timeout?: number;
+    interval?: number;
+    successText?: (received: any) => string;
+    failureText: (received: any) => string;
+}

package/dist/types/src/feature/internal/evaluationFailure.d.ts

@@ -0,0 +1,4 @@
+export default function evaluationFailure(actual: any): {
+    pass: boolean;
+    actual: any;
+};

package/dist/types/src/feature/internal/evaluationSuccess.d.ts

@@ -0,0 +1,4 @@
+export default function evaluationSuccess(actual: any): {
+    pass: boolean;
+    actual: any;
+};

package/dist/types/src/feature/internal/getAllTextContentFromPage.d.ts

@@ -0,0 +1,2 @@
+import { Page } from 'puppeteer';
+export default function getAllTextContentFromPage(page: Page): Promise<string>;

package/dist/types/src/feature/internal/isPuppeteerPage.d.ts

@@ -0,0 +1 @@
+export default function isPuppeteerPage(page: any): boolean;

package/dist/types/src/feature/internal/matchFailure.d.ts

@@ -0,0 +1,4 @@
+export default function matchFailure(message: string | ((expected: any) => string)): {
+    pass: boolean;
+    message: (expected: any) => string;
+};

package/dist/types/src/feature/internal/matchSuccess.d.ts

@@ -0,0 +1,4 @@
+export default function matchSuccess(message: string | ((expected: any) => string)): {
+    pass: boolean;
+    message: (expected: any) => string;
+};

package/dist/types/src/feature/internal/requirePuppeteerPage.d.ts

@@ -0,0 +1 @@
+export default function requirePuppeteerPage(argumentPassedToExpect: any): void;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { Page } from 'puppeteer';
+export default function toMatchTextContent(argumentPassedToExpect: Page, expected: string): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;

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

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

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

@@ -0,0 +1,5 @@
+import { Page } from 'puppeteer';
+export default function toNotMatchTextContent(argumentPassedToExpect: Page, expected: string): Promise<{
+    message: () => string;
+    pass: boolean;
+}>;

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

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

package/dist/types/src/index.d.ts

@@ -0,0 +1,45 @@
+import { ExpectToEvaluateOpts } from './feature/internal/evaluateWithRetryAndTimeout.js';
+import { CustomMatcherResult } from './feature/helpers/providePuppeteerViteMatchers.js';
+export { default as specRequest } from './unit/SpecRequest.js';
+export { default as createPsychicServer } from './unit/createPsychicServer.js';
+export { SpecRequest } from './unit/SpecRequest.js';
+export { SpecSession } from './unit/SpecSession.js';
+export { default as providePuppeteerViteMatchers } from './feature/helpers/providePuppeteerViteMatchers.js';
+export { default as launchBrowser } from './feature/helpers/launchBrowser.js';
+export { default as launchPage } from './feature/helpers/launchPage.js';
+export { default as launchViteServer, stopViteServer } from './feature/helpers/launchViteServer.js';
+export { default as visit } from './feature/helpers/visit.js';
+declare global {
+    function context(description: string, callback: () => void): void;
+}
+declare module 'vitest' {
+    interface ExpectStatic extends PuppeteerAssertions {
+    }
+    interface Assertion extends PuppeteerAssertions {
+    }
+}
+interface PuppeteerAssertions {
+    toMatchDreamModel(expected: any): CustomMatcherResult;
+    toMatchDreamModels(expected: any): CustomMatcherResult;
+    toBeWithin(precision: number, expected: number): CustomMatcherResult;
+    toEqualCalendarDate(expected: any): CustomMatcherResult;
+    toMatchTextContent(expected: any): Promise<CustomMatcherResult>;
+    toNotMatchTextContent(expected: any): Promise<CustomMatcherResult>;
+    toHaveSelector(expected: any): Promise<CustomMatcherResult>;
+    toNotHaveSelector(expected: any): Promise<CustomMatcherResult>;
+    toCheck(expected: any): Promise<CustomMatcherResult>;
+    toClick(expected: any): Promise<CustomMatcherResult>;
+    toClickLink(expected: any): Promise<CustomMatcherResult>;
+    toClickLink(expected: any): Promise<CustomMatcherResult>;
+    toClickSelector(expected: any): Promise<CustomMatcherResult>;
+    toHavePath(expected: any): Promise<CustomMatcherResult>;
+    toHaveUrl(expected: any): Promise<CustomMatcherResult>;
+    toHaveChecked(expected: any): Promise<CustomMatcherResult>;
+    toHaveUnchecked(expected: any): Promise<CustomMatcherResult>;
+    toHaveLink(expected: any): Promise<CustomMatcherResult>;
+    toFill(cssSelector: string, text: string): Promise<CustomMatcherResult>;
+    toUncheck(expected: any): Promise<CustomMatcherResult>;
+    toEvaluate(expected: (a: any) => boolean | Promise<boolean>, opts: ExpectToEvaluateOpts): Promise<CustomMatcherResult>;
+}
+declare const _default: {};
+export default _default;

package/dist/types/src/shared/sleep.d.ts

@@ -0,0 +1 @@
+export default function sleep(ms: number): Promise<unknown>;

package/dist/types/src/unit/SpecRequest.d.ts

@@ -0,0 +1,34 @@
+import { Response } from 'supertest';
+import { HttpMethod } from './supersession.js';
+import { SpecSession } from './SpecSession.js';
+export declare class SpecRequest {
+    private PsychicServer;
+    private server;
+    get(uri: string, expectedStatus: number, opts?: SpecRequestOptsGet): Promise<Response>;
+    post(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    put(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    patch(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    delete(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    init(PsychicServer: any): Promise<void>;
+    session(uri: string, credentials: object, expectedStatus: number, opts?: SpecRequestSessionOpts): Promise<SpecSession>;
+    private makeRequest;
+}
+export interface SpecRequestOptsAll extends SpecRequestOpts {
+    query?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+}
+export interface SpecRequestOptsGet extends SpecRequestOpts {
+    query?: any;
+}
+export interface SpecRequestOptsPost extends SpecRequestOpts {
+    data?: any;
+}
+export interface SpecRequestOpts {
+    headers?: Record<string, string>;
+    allowMocks?: boolean;
+}
+export interface SpecRequestSessionOpts extends SpecRequestOptsAll {
+    httpMethod?: HttpMethod;
+}
+declare const _default: SpecRequest;
+export default _default;

package/dist/types/src/unit/SpecSession.d.ts

@@ -0,0 +1,29 @@
+import { Response } from 'supertest';
+import supersession, { HttpMethod } from './supersession.js';
+export declare class SpecSession {
+    private _session;
+    constructor(_session: ReturnType<typeof supersession>);
+    get(uri: string, expectedStatus: number, opts?: SpecRequestOptsGet): Promise<Response>;
+    post(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    put(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    patch(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    delete(uri: string, expectedStatus: number, opts?: SpecRequestOptsPost): Promise<Response>;
+    private makeRequest;
+}
+export interface SpecRequestOptsAll extends SpecRequestOpts {
+    query?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+}
+export interface SpecRequestOptsGet extends SpecRequestOpts {
+    query?: any;
+}
+export interface SpecRequestOptsPost extends SpecRequestOpts {
+    data?: any;
+}
+export interface SpecRequestOpts {
+    headers?: Record<string, string>;
+    allowMocks?: boolean;
+}
+export interface SpecRequestSessionOpts extends SpecRequestOptsAll {
+    httpMethod?: HttpMethod;
+}

package/dist/types/src/unit/createPsychicServer.d.ts

@@ -0,0 +1 @@
+export default function createPsychicServer(PsychicServer: any): Promise<any>;

package/dist/types/src/unit/supersession.d.ts

@@ -0,0 +1,6 @@
+import request from 'supertest';
+type AgentOptions = Parameters<typeof request.agent>[1];
+export declare const HttpMethods: readonly ["get", "post", "put", "patch", "delete", "options"];
+export type HttpMethod = (typeof HttpMethods)[number];
+export default function supersession(server: any, config?: AgentOptions): ReturnType<typeof request>;
+export {};