@tryghost/express-bookshelf-jsonapi 0.3.4

package/test/stack.test.js

@@ -0,0 +1,126 @@
+var sinon = require('sinon');
+
+var stack = require('../lib/stack');
+
+var sandbox = sinon.createSandbox();
+
+describe('Stack handler', function () {
+    var req, res;
+
+    beforeEach(function () {
+        req = {a: true};
+        res = {b: false};
+    });
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+    it('Errors with no arguments', function () {
+        expect(stack.handle).toThrow(TypeError);
+    });
+
+    it('Works with an empty array, returning req and res', function () {
+        return new Promise(function (resolve) {
+            var req = {a: true};
+            var res = {b: false};
+            stack.handle([], req, res, function finished() {
+                expect(arguments).toHaveLength(3);
+                expect(arguments[0]).toBeFalsy();
+                expect(arguments[1]).toEqual(req);
+                expect(arguments[2]).toEqual(res);
+                resolve();
+            });
+        });
+    });
+
+    it('Calls the functions in order', function () {
+        return new Promise(function (resolve) {
+            var a = sandbox.stub().callsArg(2);
+            var b = sandbox.stub().callsArg(2);
+            var testStack = [a, b];
+
+            stack.handle(testStack, req, res, function finished() {
+                expect(a.calledOnce).toBe(true);
+                expect(a.calledWith(req, res)).toBe(true);
+                expect(b.calledOnce).toBe(true);
+                expect(b.calledWith(req, res)).toBe(true);
+                expect(a.calledBefore(b)).toBe(true);
+
+                expect(arguments).toHaveLength(3);
+                expect(arguments[0]).toBeFalsy();
+                expect(arguments[1]).toEqual(req);
+                expect(arguments[2]).toEqual(res);
+                resolve();
+            });
+        });
+    });
+
+    it('Returns req with an error if a stack method errors', function () {
+        return new Promise(function (resolve) {
+            var a = sandbox.stub().callsArg(2);
+            var b = sandbox.stub().callsArgWith(2, new Error('I broked!'));
+            var testStack = [a, b];
+
+            stack.handle(testStack, req, res, function finished() {
+                expect(a.calledOnce).toBe(true);
+                expect(a.calledWith(req, res)).toBe(true);
+                expect(b.calledOnce).toBe(true);
+                expect(b.calledWith(req, res)).toBe(true);
+                expect(a.calledBefore(b)).toBe(true);
+
+                expect(arguments).toHaveLength(3);
+                expect(arguments[0]).toBeTruthy();
+                expect(arguments[0].message).toEqual('I broked!');
+                expect(arguments[1]).toEqual(req);
+                expect(arguments[2]).toEqual(res);
+
+                resolve();
+            });
+        });
+    });
+
+    it('Does not call methods after a stack method errors', function () {
+        return new Promise(function (resolve) {
+            var a = sandbox.stub().callsArg(2);
+            var b = sandbox.stub().callsArgWith(2, new Error('I broked!'));
+            var c = sandbox.stub().callsArg(2);
+            var testStack = [a, b, c];
+
+            stack.handle(testStack, req, res, function finished() {
+                expect(a.calledOnce).toBe(true);
+                expect(a.calledWith(req, res)).toBe(true);
+                expect(b.calledOnce).toBe(true);
+                expect(b.calledWith(req, res)).toBe(true);
+                expect(c.called).toBe(false);
+                expect(a.calledBefore(b)).toBe(true);
+
+                expect(arguments).toHaveLength(3);
+                expect(arguments[0]).toBeTruthy();
+                expect(arguments[0].message).toEqual('I broked!');
+                expect(arguments[1]).toEqual(req);
+                expect(arguments[2]).toEqual(res);
+
+                resolve();
+            });
+        });
+    });
+
+    it('Does not call methods if callback method errors', function () {
+        return new Promise(function (resolve) {
+            var a = sandbox.stub().callsArg(2);
+            var b = sandbox.stub().callsArg(2);
+            var testStack = [a, b];
+
+            try {
+                stack.handle(testStack, req, res, function finished() {
+                    throw new Error('HAHAHAHAH');
+                });
+            } catch {
+                expect(a.calledOnce).toBe(true);
+                expect(b.calledOnce).toBe(true);
+                resolve();
+            }
+        });
+    });
+});

package/test/stacks/action.test.js

@@ -0,0 +1,199 @@
+var sinon = require('sinon');
+var utils = require('../utils');
+var _ = require('lodash');
+
+var apiware = require('../../lib/apiware');
+var stack = require('../../lib/stack');
+var errors = require('ghost-ignition').errors;
+
+var sandbox = sinon.createSandbox();
+
+describe('Stack: action', function () {
+    var actionStack, req, res;
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+
+    beforeEach(function () {
+        var fakeModel = utils.fakeModel({
+            getOne: sandbox.stub().resolves(),
+            otherMethod: sandbox.stub().resolves({id: 'cde'})
+        });
+
+        req = {
+            model: fakeModel,
+            options: {},
+            params: {},
+            query: {
+                data: {},
+                options: {}
+            }
+        };
+        res = {
+            exec: []
+        };
+
+        // Create a spy version of the stack
+        actionStack = {};
+        _.forEach(apiware.action, function (value, key) {
+            actionStack[key] = sandbox.spy(value);
+        });
+    });
+
+    it('Calls the methods in order', function () {
+        return new Promise(function (resolve, reject) {
+            stack.handle(_.values(actionStack), req, res, function finishing(err) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(actionStack.validate.calledOnce).toBe(true);
+                expect(actionStack.payload.calledOnce).toBe(true);
+                expect(actionStack.permissions.calledOnce).toBe(true);
+                expect(actionStack.action.calledOnce).toBe(true);
+                expect(actionStack.query.calledOnce).toBe(true);
+                expect(actionStack.process.calledOnce).toBe(true);
+                expect(actionStack.format.calledOnce).toBe(true);
+
+                sinon.assert.callOrder(
+                    actionStack.validate,
+                    actionStack.payload,
+                    actionStack.permissions,
+                    actionStack.action,
+                    actionStack.query,
+                    actionStack.process,
+                    actionStack.format
+                );
+
+                resolve();
+            });
+        });
+    });
+
+    it('Calls no action and the getOne query method by default', function () {
+        return new Promise(function (resolve, reject) {
+            stack.handle(_.values(actionStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(1);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'getOne');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('data');
+                expect(apiRes.exec[0].payload).toHaveProperty('options');
+
+                resolve();
+            });
+        });
+    });
+
+    it('Can set the action method', function () {
+        return new Promise(function (resolve, reject) {
+            req.options.actionMethod = 'otherMethod';
+
+            stack.handle(_.values(actionStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(2);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'otherMethod');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+
+                expect(apiRes.exec[1]).toHaveProperty('method', 'getOne');
+                expect(apiRes.exec[1]).toHaveProperty('payload');
+                expect(apiRes.exec[1].payload).toHaveProperty('data');
+                expect(apiRes.exec[1].payload).toHaveProperty('options');
+
+                expect(req.model.otherMethod.calledOnce).toBe(true);
+                expect(req.model.otherMethod.calledWith(apiRes.exec[0].payload)).toBe(true);
+                expect(actionStack.action.calledOnce).toBe(true);
+                expect(actionStack.query.calledOnce).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+    it('Passes through the identifier, if there is one', function () {
+        return new Promise(function (resolve, reject) {
+            req.params.identifier = 'cba';
+            req.options.actionMethod = 'otherMethod';
+
+            stack.handle(_.values(actionStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(2);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'otherMethod');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('id', 'cba');
+
+                expect(apiRes.exec[1]).toHaveProperty('method', 'getOne');
+                expect(apiRes.exec[1]).toHaveProperty('payload');
+                expect(apiRes.exec[1].payload).toHaveProperty('data');
+                expect(apiRes.exec[1].payload).toHaveProperty('options');
+
+                expect(req.model.otherMethod.calledOnce).toBe(true);
+                expect(req.model.otherMethod.calledWith(apiRes.exec[0].payload)).toBe(true);
+                expect(actionStack.action.calledOnce).toBe(true);
+                expect(actionStack.query.calledOnce).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+    it('catches bookshelf no rows errors and converts them to ignition errors', function () {
+        return new Promise(function (resolve, reject) {
+            req.options.actionMethod = 'otherMethod';
+            req.model.otherMethod.rejects(new req.model.NoRowsUpdatedError());
+
+            stack.handle(_.values(actionStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    utils.expectIgnitionError(err, 'NotFoundError');
+
+                    expect(req.model.otherMethod.calledOnce).toBe(true);
+                    expect(req.model.otherMethod.calledWith(apiRes.exec[0].payload)).toBe(true);
+                    expect(actionStack.action.calledOnce).toBe(true);
+                    expect(actionStack.query.called).toBe(false);
+
+
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+
+    it('catches but does not convert unknown errors', function () {
+        return new Promise(function (resolve, reject) {
+            req.options.actionMethod = 'otherMethod';
+            req.model.otherMethod.rejects(new Error('Unknown'));
+
+            stack.handle(_.values(actionStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    expect(err).not.toBeInstanceOf(errors.IgnitionError);
+                    expect(err.message).toEqual('Unknown');
+
+                    expect(req.model.otherMethod.calledOnce).toBe(true);
+                    expect(req.model.otherMethod.calledWith(apiRes.exec[0].payload)).toBe(true);
+                    expect(actionStack.action.calledOnce).toBe(true);
+                    expect(actionStack.query.called).toBe(false);
+
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+});

package/test/stacks/destroy.test.js

@@ -0,0 +1,171 @@
+var sinon = require('sinon');
+var utils = require('../utils');
+var _ = require('lodash');
+
+var apiware = require('../../lib/apiware');
+var stack = require('../../lib/stack');
+var errors = require('ghost-ignition').errors;
+
+var sandbox = sinon.createSandbox();
+
+describe('Stack: destroy', function () {
+    var destroyStack, req, res;
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+    beforeEach(function () {
+        var fakeModel = utils.fakeModel({
+            destroy: sandbox.stub().resolves(),
+            otherMethod: sandbox.stub().resolves()
+        });
+
+        req = {
+            model: fakeModel,
+            params: {identifier: 'abc'},
+            options: {},
+            query: {
+                data: {},
+                options: {}
+            }
+        };
+        res = {
+            exec: []
+        };
+
+        // Create a spy version of the stack
+        destroyStack = {};
+        _.forEach(apiware.destroy, function (value, key) {
+            destroyStack[key] = sandbox.spy(value);
+        });
+    });
+
+    it('Calls the methods in order', function () {
+        return new Promise(function (resolve, reject) {
+            stack.handle(_.values(destroyStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(1);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'destroy');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('id', 'abc');
+
+                expect(destroyStack.permissions.calledOnce).toBe(true);
+                expect(destroyStack.permissions.calledWith(req, res)).toBe(true);
+                expect(destroyStack.destroy.calledOnce).toBe(true);
+                expect(destroyStack.destroy.calledWith(req, res)).toBe(true);
+                expect(destroyStack.destroy.calledAfter(destroyStack.permissions)).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+    it('Calls the model.destroy method by default', function () {
+        return new Promise(function (resolve, reject) {
+            stack.handle(_.values(destroyStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(1);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'destroy');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('id', 'abc');
+
+                expect(req.model.destroy.calledOnce).toBe(true);
+                expect(req.model.destroy.calledWith(apiRes.exec[0].payload)).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+
+    it('Can override the model.destroy method', function () {
+        return new Promise(function (resolve, reject) {
+            req.options.destroyMethod = 'otherMethod';
+
+            stack.handle(_.values(destroyStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(1);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'otherMethod');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('id', 'abc');
+
+                expect(req.model.destroy.called).toBe(false);
+                expect(req.model.otherMethod.calledOnce).toBe(true);
+                expect(req.model.otherMethod.calledWith(apiRes.exec[0].payload)).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+    it('catches bookshelf no rows errors and converts them to ignition errors', function () {
+        return new Promise(function (resolve, reject) {
+            req.model.destroy.rejects(new req.model.NoRowsDeletedError());
+
+            stack.handle(_.values(destroyStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err) {
+                if (err) {
+                    utils.expectIgnitionError(err, 'NotFoundError');
+
+                    expect(destroyStack.permissions.calledOnce).toBe(true);
+                    expect(destroyStack.destroy.calledOnce).toBe(true);
+
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+
+    it('catches but does not convert unknown errors', function () {
+        return new Promise(function (resolve, reject) {
+            req.model.destroy.rejects(new Error('Unknown'));
+
+            stack.handle(_.values(destroyStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err) {
+                if (err) {
+                    expect(err).not.toBeInstanceOf(errors.IgnitionError);
+                    expect(err.message).toEqual('Unknown');
+
+                    expect(destroyStack.permissions.calledOnce).toBe(true);
+                    expect(destroyStack.destroy.calledOnce).toBe(true);
+
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+
+    it('Errors if there is no identifier', function () {
+        return new Promise(function (resolve, reject) {
+            delete req.params.identifier;
+
+            stack.handle(_.values(destroyStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err) {
+                if (err) {
+                    utils.expectIgnitionError(err, 'BadRequestError', /identifier/);
+
+
+                    expect(destroyStack.permissions.calledOnce).toBe(true);
+                    expect(destroyStack.destroy.calledOnce).toBe(true);
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+});

package/test/stacks/query.test.js

@@ -0,0 +1,198 @@
+var sinon = require('sinon');
+var utils = require('../utils');
+var _ = require('lodash');
+
+var apiware = require('../../lib/apiware');
+var stack = require('../../lib/stack');
+var errors = require('ghost-ignition').errors;
+
+var sandbox = sinon.createSandbox();
+
+describe('Stack: query', function () {
+    var queryStack, req, res;
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+
+    beforeEach(function () {
+        var fakeModel = utils.fakeModel({
+            getOne: sandbox.stub().resolves(),
+            getPage: sandbox.stub().resolves(),
+            otherMethod: sandbox.stub().resolves()
+        });
+
+        req = {
+            model: fakeModel,
+            options: {},
+            params: {
+                queryData: {
+                    page: {}
+                }
+            },
+            query: {
+                data: {},
+                options: {}
+            }
+        };
+        res = {
+            exec: []
+        };
+
+        // Create a spy version of the stack
+        queryStack = {};
+        _.forEach(apiware.query, function (value, key) {
+            queryStack[key] = sandbox.spy(value);
+        });
+    });
+
+    it('Calls the methods in order', function () {
+        return new Promise(function (resolve, reject) {
+            stack.handle(_.values(queryStack), req, res, function finishing(err) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(queryStack.validate.calledOnce).toBe(true);
+                expect(queryStack.paramsData.calledOnce).toBe(true);
+                expect(queryStack.paramsInclude.calledOnce).toBe(true);
+                expect(queryStack.paramsPage.calledOnce).toBe(true);
+                expect(queryStack.paramsFilter.calledOnce).toBe(true);
+                expect(queryStack.paramsFields.calledOnce).toBe(true);
+                expect(queryStack.paramsSort.calledOnce).toBe(true);
+                expect(queryStack.permissions.calledOnce).toBe(true);
+                expect(queryStack.query.calledOnce).toBe(true);
+                expect(queryStack.process.calledOnce).toBe(true);
+                expect(queryStack.format.calledOnce).toBe(true);
+
+                sinon.assert.callOrder(
+                    queryStack.validate,
+                    queryStack.paramsData,
+                    queryStack.paramsInclude,
+                    queryStack.paramsPage,
+                    queryStack.paramsFilter,
+                    queryStack.paramsFields,
+                    queryStack.paramsSort,
+                    queryStack.permissions,
+                    queryStack.query,
+                    queryStack.process,
+                    queryStack.format
+                );
+
+                resolve();
+            });
+        });
+    });
+
+    it('Calls the getOne query method by default', function () {
+        return new Promise(function (resolve, reject) {
+            stack.handle(_.values(queryStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(1);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'getOne');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('data');
+                expect(apiRes.exec[0].payload).toHaveProperty('options');
+
+                resolve();
+            });
+        });
+    });
+
+    it('Can set the query method', function () {
+        return new Promise(function (resolve, reject) {
+            req.options.queryMethod = 'otherMethod';
+
+            stack.handle(_.values(queryStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(apiRes.exec[0]).toHaveProperty('method', 'otherMethod');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('data');
+                expect(apiRes.exec[0].payload).toHaveProperty('options');
+
+                expect(req.model.otherMethod.calledOnce).toBe(true);
+                expect(req.model.otherMethod.calledWith(apiRes.exec[0].payload)).toBe(true);
+                expect(queryStack.query.calledOnce).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+    it('Passes through the identifier, if there is one', function () {
+        return new Promise(function (resolve, reject) {
+            req.params.identifier = 'cba';
+
+            stack.handle(_.values(queryStack), req, res, function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    return reject(err);
+                }
+
+                expect(Array.isArray(apiRes.exec)).toBe(true);
+                expect(apiRes.exec).toHaveLength(1);
+                expect(apiRes.exec[0]).toHaveProperty('method', 'getOne');
+                expect(apiRes.exec[0]).toHaveProperty('payload');
+                expect(apiRes.exec[0].payload).toHaveProperty('data');
+                expect(apiRes.exec[0].payload).toHaveProperty('options');
+                expect(apiRes.exec[0].payload.data).toHaveProperty('id', 'cba');
+
+                expect(req.model.getOne.calledOnce).toBe(true);
+                expect(req.model.getOne.calledWith(apiRes.exec[0].payload)).toBe(true);
+                expect(queryStack.query.calledOnce).toBe(true);
+
+                resolve();
+            });
+        });
+    });
+
+    it('catches bookshelf no rows errors and converts them to ignition errors', function () {
+        return new Promise(function (resolve, reject) {
+            req.model.getOne.rejects(new req.model.NotFoundError());
+
+            stack.handle(_.values(queryStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    utils.expectIgnitionError(err, 'NotFoundError');
+
+                    expect(req.model.getOne.calledOnce).toBe(true);
+                    expect(req.model.getOne.calledWith(apiRes.exec[0].payload)).toBe(true);
+                    expect(queryStack.query.called).toBe(true);
+                    expect(queryStack.process.called).toBe(false);
+
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+
+    it('catches but does not convert unknown errors', function () {
+        return new Promise(function (resolve, reject) {
+            req.model.getOne.rejects(new Error('Unknown'));
+
+            stack.handle(_.values(queryStack), _.cloneDeep(req), _.cloneDeep(res), function finishing(err, apiReq, apiRes) {
+                if (err) {
+                    expect(err).not.toBeInstanceOf(errors.IgnitionError);
+                    expect(err.message).toEqual('Unknown');
+
+                    expect(req.model.getOne.calledOnce).toBe(true);
+                    expect(req.model.getOne.calledWith(apiRes.exec[0].payload)).toBe(true);
+                    expect(queryStack.query.called).toBe(true);
+                    expect(queryStack.process.called).toBe(false);
+
+                    return resolve();
+                }
+
+                reject(new Error('This should have thrown an error'));
+            });
+        });
+    });
+});