@rvoh/psychic-spec-helpers 0.6.1 → 0.7.0

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/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 {};

package/dist/esm/test-app/src/app/controllers/UserController.js

@@ -0,0 +1,84 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { OpenAPI } from '@rvoh/psychic';
+import User from '../models/User.js';
+import ApplicationController from './ApplicationController.js';
+let UserController = (() => {
+    let _classSuper = ApplicationController;
+    let _instanceExtraInitializers = [];
+    let _create_decorators;
+    let _show_decorators;
+    let _update_decorators;
+    let _updatePut_decorators;
+    let _destroy_decorators;
+    return class UserController extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _create_decorators = [OpenAPI(User, {
+                    status: 201,
+                })];
+            _show_decorators = [OpenAPI(User)];
+            _update_decorators = [OpenAPI(User, { status: 204 })];
+            _updatePut_decorators = [OpenAPI(User, { status: 204 })];
+            _destroy_decorators = [OpenAPI(User, { status: 204 })];
+            __esDecorate(this, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _show_decorators, { kind: "method", name: "show", static: false, private: false, access: { has: obj => "show" in obj, get: obj => obj.show }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _update_decorators, { kind: "method", name: "update", static: false, private: false, access: { has: obj => "update" in obj, get: obj => obj.update }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _updatePut_decorators, { kind: "method", name: "updatePut", static: false, private: false, access: { has: obj => "updatePut" in obj, get: obj => obj.updatePut }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _destroy_decorators, { kind: "method", name: "destroy", static: false, private: false, access: { has: obj => "destroy" in obj, get: obj => obj.destroy }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        create() {
+            this.created();
+        }
+        show() {
+            this.ok();
+        }
+        update() {
+            this.noContent();
+        }
+        updatePut() {
+            this.noContent();
+        }
+        destroy() {
+            this.noContent();
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
+export default UserController;