@tryghost/express-bookshelf-jsonapi 0.3.4

package/test/structure.test.js

@@ -0,0 +1,352 @@
+var sinon = require('sinon');
+var _ = require('lodash');
+
+// This is what calling models require
+var ebja = require('../index');
+var stack = require('../lib/stack');
+var http = require('../lib/http');
+var apiware = require('../lib/apiware');
+
+var sandbox = sinon.createSandbox();
+
+describe('Structure: Method Signatures', function () {
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+    describe('EBJA', function () {
+        it('exposes a plugin', function () {
+            expect(Object.prototype.hasOwnProperty.call(ebja, 'plugin')).toBe(true);
+            expect(typeof ebja.plugin).toBe('function');
+        });
+
+        it('plugin also registers plugins if they are not yet registered', function () {
+            var fakeBookshelf = {
+                Model: {
+                    extend: sandbox.spy()
+                },
+                plugin: sandbox.spy()
+
+            };
+
+            ebja.plugin(fakeBookshelf);
+
+            expect(fakeBookshelf.plugin.calledTwice).toBe(true);
+            expect(fakeBookshelf.plugin.firstCall.calledWith(require('bookshelf-jsonapi-params'))).toBe(true);
+            expect(fakeBookshelf.plugin.secondCall.calledWith('pagination')).toBe(true);
+        });
+
+        it('plugin does not register plugins if they are already registered', function () {
+            var fakeBookshelf = {
+                Model: {
+                    extend: sandbox.stub(),
+                    fetchJsonApi: '',
+                    fetchPage: ''
+                },
+                plugin: sandbox.spy()
+
+            };
+
+            ebja.plugin(fakeBookshelf);
+
+            expect(fakeBookshelf.plugin.called).toBe(false);
+        });
+
+        it('calls extend with correct properties', function () {
+            var fakeBookshelf = {
+                Model: {
+                    extend: sandbox.stub().returnsThis()
+                },
+                plugin: sandbox.spy()
+
+            };
+
+            ebja.plugin(fakeBookshelf);
+
+            expect(fakeBookshelf.Model.extend.calledOnce).toBe(true);
+            expect(fakeBookshelf.Model.extend.firstCall.args[0]).toEqual({jsonapi: true});
+            expect(fakeBookshelf.Model.extend.firstCall.args[1]).toHaveProperty('getOne');
+            expect(fakeBookshelf.Model.extend.firstCall.args[1]).toHaveProperty('getPage');
+        });
+    });
+
+    describe('API', function () {
+        it('throws error with no config', function () {
+            function setupEbja() {
+                return ebja();
+            }
+
+            expect(setupEbja).toThrow(Error);
+            expect(setupEbja).toThrow(/requires configuration/);
+        });
+
+        it('throws error with no baseUrl', function () {
+            function setupEbja() {
+                return ebja({
+                    models: []
+                });
+            }
+            expect(setupEbja).toThrow(Error);
+            expect(setupEbja).toThrow(/requires a baseUrl/);
+        });
+
+        it('throws error with no models', function () {
+            function setupEbja() {
+                return ebja({
+                    baseUrl: 'thing'
+                });
+            }
+            expect(setupEbja).toThrow(Error);
+            expect(setupEbja).toThrow(/requires bookshelf models/);
+        });
+
+        it('can setup with all config values', function () {
+            function setupEbja() {
+                return ebja({
+                    baseUrl: 'thing',
+                    models: []
+                });
+            }
+
+            expect(setupEbja).not.toThrow();
+        });
+
+        it('setupa api exposes public methods', function () {
+            var api = ebja({
+                baseUrl: 'thing',
+                models: []
+            });
+
+            expect(Object.prototype.hasOwnProperty.call(api, 'Endpoint')).toBe(true);
+            expect(Object.prototype.hasOwnProperty.call(api, 'Resource')).toBe(true);
+
+            expect(typeof api.Endpoint).toBe('function');
+            expect(api.Endpoint).toHaveProperty('name', 'registerEndpoint');
+            expect(typeof api.Resource).toBe('function');
+            expect(api.Resource).toHaveProperty('name', 'registerResource');
+        });
+    });
+
+    describe('Endpoint', function () {
+        var api;
+        beforeEach(function () {
+            api = ebja({
+                baseUrl: 'thing',
+                models: []
+            });
+        });
+
+        afterEach(function () {
+            sandbox.restore();
+        });
+
+        it('throws error with no options', function () {
+            function setupEndpoint() {
+                api.Endpoint();
+            }
+
+            expect(setupEndpoint).toThrow(Error);
+        });
+
+        it('can register an endpoint with empty options object', function () {
+            function setupEndpoint() {
+                return api.Endpoint({});
+            }
+
+            expect(setupEndpoint).not.toThrow();
+        });
+
+        it('an endpoint is a handler function', function () {
+            var ep = api.Endpoint({});
+            expect(typeof ep).toBe('function');
+            expect(ep).toHaveProperty('name', 'handler');
+        });
+
+        it('endpoint handler function throws error without arguments', function () {
+            var ep = api.Endpoint({});
+            expect(ep).toThrow(Error);
+        });
+
+        it('endpoint handler can be called as middleware', function () {
+            return new Promise(function (resolve) {
+                var options = {request: {}, response: {}};
+                var ep = api.Endpoint(options);
+                var req = {__proto__: require('http').IncomingMessage.prototype};
+                var res = {};
+                var next = function callback() {
+                    expect(httpStub.calledOnce).toBe(true);
+                    expect(httpStub.calledWith(api, options, req, res, next)).toBe(true);
+                    expect(queueStub.calledOnce).toBe(true);
+                    expect(queueStub.calledWith(_.values(apiware.query))).toBe(true);
+
+                    resolve();
+                };
+
+                var queueStub = sandbox.stub(stack, 'handle').callsArg(3);
+                var httpStub = sandbox.stub(http, 'adapter').returns([{}, {}, next]);
+
+                ep(req, res, next);
+            });
+        });
+    });
+
+    describe('Resource', function () {
+        var api;
+        beforeEach(function () {
+            api = ebja({
+                baseUrl: 'thing',
+                models: []
+            });
+        });
+
+        afterEach(function () {
+            sandbox.restore();
+        });
+
+        it('throws error with no options', function () {
+            function setupResource() {
+                api.Resource();
+            }
+
+            expect(setupResource).toThrow(Error);
+        });
+
+        it('can register an endpoint with empty options object', function () {
+            function setupResource() {
+                return api.Resource({});
+            }
+
+            expect(setupResource).not.toThrow();
+        });
+
+        it('resource is just an object with an Endpoint function', function () {
+            var rs = api.Resource({});
+
+            expect(typeof rs).toBe('object');
+            expect(rs).toHaveProperty('Endpoint');
+            expect(typeof rs.Endpoint).toBe('function');
+            expect(rs.Endpoint).toHaveProperty('name', 'registerEndpoint');
+        });
+
+        describe('Resource.Endpoint', function () {
+            var rs;
+            beforeEach(function () {
+                rs = api.Resource({});
+            });
+
+
+            it('throws error with no options', function () {
+                function setupEndpoint() {
+                    rs.Endpoint();
+                }
+
+                expect(setupEndpoint).toThrow(Error);
+            });
+
+            it('can register an endpoint with empty options object', function () {
+                function setupEndpoint() {
+                    return rs.Endpoint({});
+                }
+
+                expect(setupEndpoint).not.toThrow();
+            });
+
+            it('an endpoint is a handler function', function () {
+                var ep = rs.Endpoint({});
+                expect(typeof ep).toBe('function');
+                expect(ep).toHaveProperty('name', 'handler');
+            });
+
+            it('endpoint handler function throws error without arguments', function () {
+                var ep = rs.Endpoint({});
+                expect(ep).toThrow(Error);
+            });
+
+            it('endpoint handler can be called as middleware', function () {
+                return new Promise(function (resolve) {
+                    var options = {request: {}, response: {}};
+                    var ep = rs.Endpoint(options);
+                    var req = {__proto__: require('http').IncomingMessage.prototype};
+                    var res = {};
+                    var next = function callback() {
+                        expect(httpStub.calledOnce).toBe(true);
+                        expect(httpStub.calledWith(api, options, req, res, next)).toBe(true);
+                        expect(queueStub.calledOnce).toBe(true);
+
+                        resolve();
+                    };
+
+                    var queueStub = sandbox.stub(stack, 'handle').callsArg(3);
+                    var httpStub = sandbox.stub(http, 'adapter').returns([{}, {}, next]);
+
+                    ep(req, res, next);
+                });
+            });
+        });
+    });
+
+    describe('APIware stacks', function () {
+        it('exports query, action and destroy', function () {
+            expect(typeof apiware).toBe('object');
+            expect(apiware).toHaveProperty('query');
+            expect(apiware).toHaveProperty('action');
+            expect(apiware).toHaveProperty('destroy');
+        });
+
+        it('query stack is correct', function () {
+            expect(typeof apiware.query).toBe('object');
+            var keys = Object.keys(apiware.query);
+            expect(keys[0]).toBe('validate');
+            expect(apiware.query.validate.name).toBe('noop');
+            expect(keys[1]).toBe('paramsData');
+            expect(apiware.query.paramsData.name).toBe('paramsData');
+            expect(keys[2]).toBe('paramsInclude');
+            expect(apiware.query.paramsInclude.name).toBe('paramsInclude');
+            expect(keys[3]).toBe('paramsPage');
+            expect(apiware.query.paramsPage.name).toBe('paramsPage');
+            expect(keys[4]).toBe('paramsFilter');
+            expect(apiware.query.paramsFilter.name).toBe('paramsFilter');
+            expect(keys[5]).toBe('paramsFields');
+            expect(apiware.query.paramsFields.name).toBe('paramsFields');
+            expect(keys[6]).toBe('paramsSort');
+            expect(apiware.query.paramsSort.name).toBe('paramsSort');
+            expect(keys[7]).toBe('permissions');
+            expect(apiware.query.permissions.name).toBe('noop');
+            expect(keys[8]).toBe('query');
+            expect(apiware.query.query.name).toBe('query');
+            expect(keys[9]).toBe('process');
+            expect(apiware.query.process.name).toBe('noop');
+            expect(keys[10]).toBe('format');
+            expect(apiware.query.format.name).toBe('format');
+        });
+
+        it('action stack is correct', function () {
+            expect(typeof apiware.action).toBe('object');
+            var keys = Object.keys(apiware.action);
+            expect(keys[0]).toBe('validate');
+            expect(apiware.action.validate.name).toBe('noop');
+            expect(keys[1]).toBe('payload');
+            expect(apiware.action.payload.name).toBe('payload');
+            expect(keys[2]).toBe('permissions');
+            expect(apiware.action.permissions.name).toBe('noop');
+            expect(keys[3]).toBe('action');
+            expect(apiware.action.action.name).toBe('action');
+            expect(keys[4]).toBe('query');
+            expect(apiware.action.query.name).toBe('query');
+            expect(keys[5]).toBe('process');
+            expect(apiware.action.process.name).toBe('noop');
+            expect(keys[6]).toBe('format');
+            expect(apiware.action.format.name).toBe('format');
+        });
+
+        it('destroy stack is correct', function () {
+            expect(typeof apiware.destroy).toBe('object');
+            var keys = Object.keys(apiware.destroy);
+            expect(keys[0]).toBe('permissions');
+            expect(apiware.destroy.permissions.name).toBe('noop');
+            expect(keys[1]).toBe('destroy');
+            expect(apiware.destroy.destroy.name).toBe('destroy');
+        });
+    });
+});

package/test/utils.js

@@ -0,0 +1,22 @@
+var utils = exports;
+var _ = require('lodash');
+// This is the same util used by bookshelf
+var createError = require('create-error');
+var errors = require('ghost-ignition').errors;
+
+utils.fakeModel = function (options) {
+    return _.merge({}, {
+        NotFoundError: createError('NotFoundError'),
+        NoRowsDeletedError: createError('NoRowsDeletedError'),
+        NoRowsUpdatedError: createError('NoRowsUpdatedError'),
+    }, options);
+};
+
+utils.expectIgnitionError = function (error, type, messagePattern) {
+    expect(error).toBeInstanceOf(errors.IgnitionError);
+    expect(error).toHaveProperty('errorType', type);
+    expect(error).toHaveProperty('message');
+    if (messagePattern) {
+        expect(error.message).toMatch(messagePattern);
+    }
+};

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig, mergeConfig } from 'vitest/config';
+import rootConfig from '../../vitest.config';
+
+// Override: legacy package, coverage is below the root thresholds.
+// Tests were originally mocha with no coverage gate — match that behavior.
+export default mergeConfig(
+    rootConfig,
+    defineConfig({
+        test: {
+            coverage: {
+                thresholds: {
+                    lines: 0,
+                    functions: 0,
+                    branches: 0,
+                    statements: 0,
+                },
+            },
+        },
+    }),
+);