@vida-global/core 1.1.0

package/test/release/increment.test.js

@@ -0,0 +1,145 @@
+const   fs          = require('fs');
+const { increment } = require('../../lib/release/increment');
+const   Git         = require('../../lib/release/git');
+const   TestHelpers = require('@vida-global/test-helpers');
+const   utils       = require('../../lib/release/utils');
+
+
+jest.mock('../../lib/release/git', () => {
+    return { add: jest.fn(), createBranch: jest.fn(), commit: jest.fn(), pull: jest.fn(), push: jest.fn() };
+});
+jest.mock('../../lib/release/utils', () => {
+    return { getCurrentVersion: jest.fn(), confirmContinue: jest.fn() };
+});
+jest.mock('fs', () => {
+    return { readFileSync: jest.fn(), writeFileSync: jest.fn() };
+});
+
+
+let   config;
+let   version;
+const packageJsonPath = `${process.cwd()}/package.json`;
+beforeEach(() => {
+    jest.resetAllMocks();
+    version = [TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber()];
+    utils.getCurrentVersion.mockImplementation(() => version);
+    utils.confirmContinue.mockImplementation(() => true);
+
+    config = {
+      [TestHelpers.Faker.Text.randomString()]: TestHelpers.Faker.Text.randomString(),
+      [TestHelpers.Faker.Text.randomString()]: TestHelpers.Faker.Text.randomString(),
+      version: version.join('.')
+    }
+    fs.readFileSync.mockImplementation(() => JSON.stringify(config, null, 4));
+});
+
+
+describe('increment', () => {
+    it ('runs steps in the proper order', async () => {
+        await increment('point');
+
+        expect(Git.pull).toHaveBeenCalledTimes(1);
+        expect(utils.getCurrentVersion).toHaveBeenCalledTimes(1);
+        expect(Git.pull).toHaveBeenCalledBefore(utils.getCurrentVersion);
+
+        expect(utils.confirmContinue).toHaveBeenCalledTimes(1);
+        expect(utils.getCurrentVersion).toHaveBeenCalledBefore(utils.confirmContinue);
+
+        expect(Git.createBranch).toHaveBeenCalledTimes(1);
+        expect(utils.confirmContinue).toHaveBeenCalledBefore(Git.createBranch);
+
+        expect(fs.readFileSync).toHaveBeenCalledTimes(1);
+        expect(Git.createBranch).toHaveBeenCalledBefore(fs.readFileSync);
+
+        expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+        expect(fs.readFileSync).toHaveBeenCalledBefore(fs.writeFileSync);
+
+        expect(Git.push).toHaveBeenCalledTimes(1);
+        expect(fs.writeFileSync).toHaveBeenCalledBefore(Git.push);
+    });
+
+
+    describe('getNewVersion', () => {
+        it ('increments the major version', async () => {
+            await increment('major');
+            const newVersion = [...version];
+            newVersion[0]    = newVersion[0] + 1;
+            newVersion[1]    = 0;
+            newVersion[2]    = 0;
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
+        });
+
+        it ('increments the minor version', async () => {
+            await increment('minor');
+            const newVersion = [...version];
+            newVersion[1]    = newVersion[1] + 1;
+            newVersion[2]    = 0;
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
+        });
+
+        it ('increments the point version', async () => {
+            await increment('point');
+            const newVersion = [...version];
+            newVersion[2]    = newVersion[2] + 1;
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
+        });
+
+        it ('throws an error for an invalid type', async () => {
+            expect(async () => {await increment('foo')}).rejects.toThrow();;
+        });
+    });
+
+
+    describe('confirmation', () => {
+        it ('asks the user if they want to upgrade to the new version', async () => {
+            await increment('point');
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to create version ${newVersion}?`);
+        });
+
+        it ('does not continue if the user responds "n"', async () => {
+            utils.confirmContinue.mockImplementation(() => false);
+            await increment('point');
+
+            expect(Git.createBranch).not.toHaveBeenCalled();
+            expect(fs.readFileSync).not.toHaveBeenCalled();
+            expect(fs.writeFileSync).not.toHaveBeenCalled();
+            expect(Git.push).not.toHaveBeenCalled();
+        });
+    });
+
+
+    describe('createBranch', () => {
+        it ('creates a release branch for the new version', async () => {
+            await increment('point');
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion}`);
+        });
+    });
+
+
+    describe('updatePackageVersion', () => {
+        it ('writes the new package version to package.json', async () => {
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            const newConfig  = structuredClone(config);
+            newConfig.version = newVersion;
+
+            await increment('point');
+            
+            expect(fs.writeFileSync).toHaveBeenCalledWith(packageJsonPath, JSON.stringify(newConfig, null, 4));
+        });
+
+        it ('adds package.json to be committed', async () => {
+            await increment('point');
+            expect(Git.add).toHaveBeenCalledWith(packageJsonPath);
+        });
+
+        it ('adds a descriptive commit message', async () => {
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            await increment('point');
+            expect(Git.commit).toHaveBeenCalledWith(`build: incrementing build to ${newVersion}`);
+        });
+    });
+});

package/test/release/release.test.js

@@ -0,0 +1,72 @@
+const { release } = require('../../lib/release/release');
+const   Git         = require('../../lib/release/git');
+const   TestHelpers = require('@vida-global/test-helpers');
+const   utils       = require('../../lib/release/utils');
+
+
+jest.mock('../../lib/release/git', () => {
+    return { pull: jest.fn(), forceRemotePush: jest.fn(), branches: jest.fn() };
+});
+jest.mock('../../lib/release/utils', () => {
+    return { getCurrentVersion: jest.fn(), confirmContinue: jest.fn() };
+});
+
+
+let env;
+let version;
+beforeEach(() => {
+    jest.resetAllMocks();
+    env = TestHelpers.Faker.Text.randomString();
+    version = [TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber()];
+    utils.getCurrentVersion.mockImplementation(() => version);
+    utils.confirmContinue.mockImplementation(() => true);
+});
+
+
+describe('release', () => {
+    it ('runs steps in the proper order', async () => {
+        await release(env);
+
+        expect(Git.pull).toHaveBeenCalledTimes(1)
+        expect(utils.confirmContinue).toHaveBeenCalledTimes(1)
+        expect(Git.pull).toHaveBeenCalledBefore(utils.confirmContinue)
+
+        expect(Git.forceRemotePush).toHaveBeenCalledTimes(1)
+        expect(utils.confirmContinue).toHaveBeenCalledBefore(Git.forceRemotePush)
+    });
+
+    it ('defaults to the current version', async () => {
+        await release(env);
+        const versionStr = version.join('.');
+        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to release version ${versionStr} to ${env}?`);
+        expect(Git.forceRemotePush).toHaveBeenCalledWith(`release/${versionStr}`, `release/${env}`);
+    });
+    
+    it ('accepts an alternate version', async () => {
+        const altVersion = [TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber()].join('.');
+        Git.branches.mockImplementation(() => [`origin/release/${version.join('.')}`, `origin/release/${altVersion}`, TestHelpers.Faker.Text.randomString()]);
+        await release(env, altVersion);
+        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to release version ${altVersion} to ${env}?`);
+        expect(Git.forceRemotePush).toHaveBeenCalledWith(`release/${altVersion}`, `release/${env}`);
+    });
+
+    it ('does not continue if the user responds "n"', async () => {
+        utils.confirmContinue.mockImplementation(() => false);
+        await release(env);
+
+        expect(Git.forceRemotePush).not.toHaveBeenCalled();
+    });
+
+    it ('throws an error if the version does not exist', async () => {
+        const altVersion = [TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber()].join('.');
+        Git.branches.mockImplementation(() => [`origin/release/${version.join('.')}`, TestHelpers.Faker.Text.randomString()]);
+        expect(async () => { await release(env, altVersion)}).rejects.toThrow();
+    });
+});
+

package/test/release/utils.test.js

@@ -0,0 +1,148 @@
+const Git         = require('../../lib/release/git');
+const TestHelpers = require('@vida-global/test-helpers');
+const utils       = require('../../lib/release/utils');
+const readline    = require('node:readline/promises');
+
+
+jest.mock('node:readline/promises', () => {
+    return { createInterface: jest.fn(), question: jest.fn(), close: jest.fn() };
+});
+
+jest.mock('../../lib/release/git', () => {
+    return {branches: jest.fn()};
+});
+
+
+beforeEach(() => {
+    jest.resetAllMocks();
+    readline.createInterface.mockImplementation(() => {
+        return {question: readline.question, close: readline.close};
+    });
+});
+
+
+describe('getCurrentVersion', () => {
+    const major1 = TestHelpers.Faker.Math.randomNumber();
+    const minor1 = TestHelpers.Faker.Math.randomNumber();
+    const point1 = TestHelpers.Faker.Math.randomNumber();
+    const diff1  = TestHelpers.Faker.Math.randomNumber();
+    const diff2  = TestHelpers.Faker.Math.randomNumber();
+
+    const b1     = `origin/release/${major1}/${minor1}/${point1}`;
+
+    it ('sorts branches by primary version first', () => {
+        const b2 = `origin/release/${major1 + diff1        }.${minor1 + diff2}.${point1 + diff1}`;
+        const b3 = `origin/release/${major1 + diff1 + diff2}.${minor1        }.${point1}`;
+        Git.branches.mockImplementation(() => [b1, b3, b2]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1+diff2, minor1, point1]);
+    });
+
+    it ('sorts branches by minor version second', () => {
+        const b2 = `origin/release/${major1 + diff1}.${minor1 + diff1 + diff2}.${point1}`;
+        const b3 = `origin/release/${major1 + diff1}.${minor1 + diff1        }.${point1 + diff1}`;
+        Git.branches.mockImplementation(() => [b1, b3, b2]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1+diff1+diff2, point1]);
+    });
+
+    it ('sorts branches by point version last', () => {
+        const b2 = `origin/release/${major1 + diff1}.${minor1 + diff1}.${point1 + diff1}`;
+        const b3 = `origin/release/${major1 + diff1}.${minor1 + diff1}.${point1 + diff1 + diff2}`;
+        Git.branches.mockImplementation(() => [b1, b3, b2]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1+diff1, point1+diff1+diff2]);
+    });
+
+    it ('ignores branches that don not fit the pattern', () => {
+        const b2 = `origin/release/${major1 + diff1}.${minor1}.${point1}`;
+        const b3 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
+        const b4 = TestHelpers.Faker.Text.randomString();
+        Git.branches.mockImplementation(() => [b1, b3, b2, b4]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1, point1]);
+    });
+
+    it ('defaults to 1.0.0', () => {
+        const b2 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
+        const b3 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
+        const b4 = TestHelpers.Faker.Text.randomString();
+        Git.branches.mockImplementation(() => [b3, b2, b4]);
+        expect(utils.getCurrentVersion()).toEqual([1, 0, 0]);
+    });
+});
+
+
+describe('getInput', () => {
+    let question;
+    let numOptions;
+    let options;
+    let answer;
+    beforeEach(() => {
+        question   = TestHelpers.Faker.Text.randomSentence();
+        numOptions = TestHelpers.Faker.Math.randomNumber(10);
+        options    = [...Array(numOptions)].map(() => TestHelpers.Faker.Text.randomString());
+        answer     = options[Math.floor(Math.random() * numOptions)];
+        readline.question.mockImplementation(() => answer);
+    });
+
+    it ('asks the question and appends the options', async () => {
+        await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledWith(`${question} [${options.join(',')}] `);
+    });
+
+    it ('asks the question once if it gets a valid answer', async () => {
+        const theAnswer = await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledTimes(1);
+        expect(theAnswer).toEqual(answer);
+    });
+
+    it ('closes the input after getting an answer', async () => {
+        await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledTimes(1);
+        expect(readline.close).toHaveBeenCalledTimes(1);
+        expect(readline.question).toHaveBeenCalledBefore(readline.close);
+    });
+
+    it ('repeats the question until it gets a valid answer', async () => {
+        const numAttempts   = TestHelpers.Faker.Math.randomNumber(10);
+        let   attemptNumber = 1;
+
+        readline.question.mockImplementation(() => {
+            if (attemptNumber == numAttempts) return answer;
+            attemptNumber = attemptNumber + 1;
+            return TestHelpers.Faker.Text.randomString();
+        });
+
+        const theAnswer = await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledTimes(numAttempts);
+        expect(readline.close).toHaveBeenCalledTimes(numAttempts);
+        expect(theAnswer).toEqual(answer);
+
+        for(let i=1; i <= numAttempts; i++){
+            expect(readline.question).toHaveBeenNthCalledWith(i, `${question} [${options.join(',')}] `);
+        }
+    });
+});
+
+
+describe('confirmContinue', () => {
+    let question;
+    beforeEach(() => {
+        question = TestHelpers.Faker.Text.randomSentence();
+    });
+
+    it ('asks the question with "y" or "n" as options', async () => {
+        readline.question.mockImplementation(() => 'y');
+        await utils.confirmContinue(question);
+        expect(readline.question).toHaveBeenCalledWith(`${question} [y,n] `);
+    });
+
+    it ('returns true if the user answers "y"', async () => {
+        readline.question.mockImplementation(() => 'y');
+        const confirmed = await utils.confirmContinue(question);
+        expect(confirmed).toBeTruthy();
+    });
+
+    it ('returns false if the user answers "n"', async () => {
+        readline.question.mockImplementation(() => 'n');
+        const confirmed = await utils.confirmContinue(question);
+        expect(confirmed).toBeFalsy();
+    });
+});

package/test/server/helpers/controllers/barController.js

@@ -0,0 +1,9 @@
+const { VidaServerController } = require('../../../../lib/server');
+
+
+class BarController extends VidaServerController {
+
+}
+
+
+module.exports = { BarController };

package/test/server/helpers/controllers/fooController.js

@@ -0,0 +1,48 @@
+const { VidaServerController } = require('../../../../lib/server');
+
+
+class FooController extends VidaServerController {
+    postIndex() {}
+    getFooBar() {}
+    getBazBan() {}
+    postFooBar() {}
+    putFooBar() {}
+    deleteFooBar() {}
+    patchFooBar() {}
+    notAnAction() {}
+
+    static get routes() {
+        return {getBazBan: '/baz/:id/ban'};
+    }
+
+
+    setupCallbacks() {
+        this.beforeCallback('beforeCallback1', {only: 'postIndex'});
+        this.beforeCallback('beforeCallback2');
+        this.beforeCallback('beforeCallback3', {except: ['getFooBar', 'getBazBan']});
+        this.beforeCallback('beforeCallback4', {only: 'putFooBar'});
+        this.beforeCallback('beforeCallback5');
+
+        this.afterCallback('afterCallback1');
+        this.afterCallback('afterCallback2', {except: ['getFooBar', 'getBazBan']});
+        this.afterCallback('afterCallback3', {only: 'postIndex'});
+        this.afterCallback('afterCallback4', {only: 'deleteFooBar'});
+        this.afterCallback('afterCallback5');
+    }
+
+
+    beforeCallback1() {}
+    beforeCallback2() {}
+    beforeCallback3() {}
+    beforeCallback4() { return false; }
+    beforeCallback5() {}
+
+    afterCallback1() {}
+    afterCallback2() {}
+    afterCallback3() {}
+    afterCallback4() { return false; }
+    afterCallback5() {}
+}
+
+
+module.exports = { FooController };

package/test/server/helpers/controllers/sub/bazController.js

@@ -0,0 +1,10 @@
+const { VidaServerController } = require('../../../../../lib/server');
+
+
+class BazController extends VidaServerController {
+
+}
+
+
+module.exports = { BazController };
+

package/test/server/helpers/server.js

@@ -0,0 +1,14 @@
+const { VidaServer } = require('../../../lib/server');
+
+
+class TestServer extends VidaServer {
+    get controllerDirectories() {
+        return [`${__dirname}/controllers`];
+    }
+}
+
+
+module.exports = {
+    TestServer
+}
+

package/test/server/server.test.js

@@ -0,0 +1,188 @@
+const { BarController } = require('./helpers/controllers/barController');
+const { BazController } = require('./helpers/controllers/sub/bazController');
+const { FooController } = require('./helpers/controllers/fooController');
+const { Request }       = require('jest-express/lib/request');
+const { Response }      = require('jest-express/lib/response');
+const { TestServer }    = require('./helpers/server');
+const { VidaServer }    = require('../../lib/server');
+
+
+jest.mock('express', () => {
+    const { Response } = require('jest-express/lib/response');
+
+    // missing functions in mock Response
+    Response.prototype.on   = jest.fn();
+
+    return require('jest-express');
+});
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('VidaServer', () => {
+    describe('VidaServer#controllers', () => {
+        it ('searches directories and subdirectories', () => {
+            const server      = new TestServer();
+            const controllers = server.controllerClasses;
+            expect(controllers.length).toEqual(3);
+            expect(controllers[0]).toBe(BarController);
+            expect(controllers[1]).toBe(FooController);
+            expect(controllers[2]).toBe(BazController);
+        });
+
+        it ('initializes controllers with the correct path', () => {
+            const server      = new TestServer();
+            const controllers = server.controllerClasses;
+            expect(controllers[0].routePrefix).toEqual('/bar');
+            expect(controllers[1].routePrefix).toEqual('/foo');
+            expect(controllers[2].routePrefix).toEqual('/sub/baz');
+        });
+    });
+
+
+    describe('VidaServer#registerControllers', () => {
+        it ('it configures routes on underlying express server', () => {
+            const server = new TestServer();
+            const getSpy    = jest.spyOn(server, '_get').mockImplementation(() => null);
+            const postSpy   = jest.spyOn(server, '_post').mockImplementation(() => null);
+            const deleteSpy = jest.spyOn(server, '_delete').mockImplementation(() => null);
+            const putSpy    = jest.spyOn(server, '_put').mockImplementation(() => null);
+            const patchSpy  = jest.spyOn(server, '_patch').mockImplementation(() => null);
+            server.registerControllers();
+
+            expect(getSpy).toHaveBeenCalledTimes(4);
+            expect(getSpy).toHaveBeenCalledWith('/foo/fooBar',         expect.any(Function));
+            expect(getSpy).toHaveBeenCalledWith('/baz/:id/ban',        expect.any(Function));
+            // Built in system routes
+            expect(getSpy).toHaveBeenCalledWith('/',                   expect.any(Function));
+            expect(getSpy).toHaveBeenCalledWith('/system/healthCheck', expect.any(Function));
+
+            expect(postSpy).toHaveBeenCalledTimes(2);
+            expect(postSpy).toHaveBeenCalledWith('/foo',        expect.any(Function));
+            expect(postSpy).toHaveBeenCalledWith('/foo/fooBar', expect.any(Function));
+
+            expect(putSpy).toHaveBeenCalledTimes(1);
+            expect(putSpy).toHaveBeenCalledWith('/foo/fooBar', expect.any(Function));
+
+            expect(deleteSpy).toHaveBeenCalledTimes(1);
+            expect(deleteSpy).toHaveBeenCalledWith('/foo/fooBar', expect.any(Function));
+
+            expect(patchSpy).toHaveBeenCalledTimes(1);
+            expect(patchSpy).toHaveBeenCalledWith('/foo/fooBar', expect.any(Function));
+        });
+    });
+
+
+    describe('VidaServer#requestHandler', () => {
+        const server         = new TestServer();
+        const request        = new Request();
+        const response       = new Response();
+
+        const beforeSpy1 = jest.spyOn(FooController.prototype, 'beforeCallback1');
+        const beforeSpy2 = jest.spyOn(FooController.prototype, 'beforeCallback2');
+        const beforeSpy3 = jest.spyOn(FooController.prototype, 'beforeCallback3');
+        const beforeSpy4 = jest.spyOn(FooController.prototype, 'beforeCallback4');
+        const beforeSpy5 = jest.spyOn(FooController.prototype, 'beforeCallback5');
+
+        const afterSpy1  = jest.spyOn(FooController.prototype, 'afterCallback1');
+        const afterSpy2  = jest.spyOn(FooController.prototype, 'afterCallback2');
+        const afterSpy3  = jest.spyOn(FooController.prototype, 'afterCallback3');
+        const afterSpy4  = jest.spyOn(FooController.prototype, 'afterCallback4');
+        const afterSpy5  = jest.spyOn(FooController.prototype, 'afterCallback5');
+
+        it ('calls callbacks in the right order', async () => {
+            const postIndexSpy   = jest.spyOn(FooController.prototype, 'postIndex');
+            const requestHandler = server.requestHandler('postIndex', FooController);
+            await requestHandler(request, response);
+
+            expect(beforeSpy1).toHaveBeenCalledTimes(1);
+            expect(beforeSpy1).toHaveBeenCalledBefore(beforeSpy2);
+            expect(beforeSpy2).toHaveBeenCalledTimes(1);
+            expect(beforeSpy2).toHaveBeenCalledBefore(beforeSpy3);
+            expect(beforeSpy3).toHaveBeenCalledTimes(1);
+            expect(beforeSpy3).toHaveBeenCalledBefore(beforeSpy5);
+            expect(beforeSpy5).toHaveBeenCalledTimes(1);
+            expect(beforeSpy5).toHaveBeenCalledBefore(postIndexSpy);
+
+            expect(postIndexSpy).toHaveBeenCalledTimes(1);
+            expect(postIndexSpy).toHaveBeenCalledBefore(afterSpy1);
+
+            expect(afterSpy1).toHaveBeenCalledTimes(1);
+            expect(afterSpy1).toHaveBeenCalledBefore(afterSpy2);
+            expect(afterSpy2).toHaveBeenCalledTimes(1);
+            expect(afterSpy2).toHaveBeenCalledBefore(afterSpy3);
+            expect(afterSpy3).toHaveBeenCalledTimes(1);
+            expect(afterSpy3).toHaveBeenCalledBefore(afterSpy5);
+            expect(afterSpy5).toHaveBeenCalledTimes(1);
+        });
+
+        it ('calls does not call callbacks that should only be called for some actions', async () => {
+            const postFooBarSpy  = jest.spyOn(FooController.prototype, 'postFooBar');
+            const requestHandler = server.requestHandler('postFooBar', FooController);
+            await requestHandler(request, response);
+
+            expect(beforeSpy1).toHaveBeenCalledTimes(0);
+            expect(beforeSpy2).toHaveBeenCalledTimes(1);
+            expect(beforeSpy3).toHaveBeenCalledTimes(1);
+            expect(beforeSpy5).toHaveBeenCalledTimes(1);
+
+            expect(postFooBarSpy).toHaveBeenCalledTimes(1);
+
+            expect(afterSpy1).toHaveBeenCalledTimes(1);
+            expect(afterSpy2).toHaveBeenCalledTimes(1);
+            expect(afterSpy3).toHaveBeenCalledTimes(0);
+            expect(afterSpy5).toHaveBeenCalledTimes(1);
+        });
+
+        it ('calls does not call callbacks that should not be called for some actions', async () => {
+            const getFooBarSpy   = jest.spyOn(FooController.prototype, 'getFooBar');
+            const requestHandler = server.requestHandler('getFooBar', FooController);
+            await requestHandler(request, response);
+
+            expect(beforeSpy1).toHaveBeenCalledTimes(0);
+            expect(beforeSpy2).toHaveBeenCalledTimes(1);
+            expect(beforeSpy3).toHaveBeenCalledTimes(0);
+            expect(beforeSpy5).toHaveBeenCalledTimes(1);
+
+            expect(getFooBarSpy).toHaveBeenCalledTimes(1);
+
+            expect(afterSpy1).toHaveBeenCalledTimes(1);
+            expect(afterSpy2).toHaveBeenCalledTimes(0);
+            expect(afterSpy3).toHaveBeenCalledTimes(0);
+            expect(afterSpy5).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not call the action when a callback return false', async () => {
+            const putFooBarSpy   = jest.spyOn(FooController.prototype, 'putFooBar');
+            const requestHandler = server.requestHandler('putFooBar', FooController);
+            await requestHandler(request, response);
+
+            expect(beforeSpy4).toHaveBeenCalledTimes(1);
+            expect(beforeSpy5).toHaveBeenCalledTimes(0);
+
+            expect(putFooBarSpy).toHaveBeenCalledTimes(0);
+
+            expect(afterSpy1).toHaveBeenCalledTimes(0);
+            expect(afterSpy2).toHaveBeenCalledTimes(0);
+            expect(afterSpy3).toHaveBeenCalledTimes(0);
+            expect(afterSpy5).toHaveBeenCalledTimes(0);
+        });
+
+        it ('does not call the subsequent callbacks  when a callback return false', async () => {
+            const deleteFooBarSpy   = jest.spyOn(FooController.prototype, 'deleteFooBar');
+            const requestHandler = server.requestHandler('deleteFooBar', FooController);
+            await requestHandler(request, response);
+
+            expect(deleteFooBarSpy).toHaveBeenCalledTimes(1);
+
+            expect(afterSpy1).toHaveBeenCalledTimes(1);
+            expect(afterSpy2).toHaveBeenCalledTimes(1);
+            expect(afterSpy3).toHaveBeenCalledTimes(0);
+            expect(afterSpy4).toHaveBeenCalledTimes(1);
+            expect(afterSpy5).toHaveBeenCalledTimes(0);
+        });
+    });
+});