js-trie-router/src/hooks/hook-invoker.spec.js

import {expect} from 'chai';
import {format} from '@e22m4u/js-format';
import {ROOT_PATH} from '../constants.js';
import {HookInvoker} from './hook-invoker.js';
import {Route, HttpMethod} from '../route/index.js';
import {createResponseMock} from '../utils/index.js';
import {HookRegistry, RouterHookType} from './hook-registry.js';

describe('HookInvoker', function () {
  describe('invokeAndContinueUntilValueReceived', function () {
    it('requires the parameter "route" to be a Route instance', function () {
      const s = new HookInvoker();
      const res = createResponseMock();
      const throwable = v => () =>
        s.invokeAndContinueUntilValueReceived(
          v,
          RouterHookType.PRE_HANDLER,
          res,
        );
      const error = v =>
        format(
          'The parameter "route" of ' +
            'the HookInvoker.invokeAndContinueUntilValueReceived ' +
            'must be a Route instance, but %s was given.',
          v,
        );
      expect(throwable('str')).to.throw(error('"str"'));
      expect(throwable('')).to.throw(error('""'));
      expect(throwable(10)).to.throw(error('10'));
      expect(throwable(0)).to.throw(error('0'));
      expect(throwable(true)).to.throw(error('true'));
      expect(throwable(false)).to.throw(error('false'));
      expect(throwable(null)).to.throw(error('null'));
      expect(throwable({})).to.throw(error('Object'));
      expect(throwable([])).to.throw(error('Array'));
      expect(throwable(undefined)).to.throw(error('undefined'));
      throwable(
        new Route({
          method: HttpMethod.GET,
          path: ROOT_PATH,
          handler: () => undefined,
        }),
      )();
    });

    it('requires the parameter "hookType" to be a non-empty String', function () {
      const s = new HookInvoker();
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        handler: () => undefined,
      });
      const res = createResponseMock();
      const throwable = v => () =>
        s.invokeAndContinueUntilValueReceived(route, v, res);
      const error = v =>
        format(
          'The parameter "hookType" of ' +
            'the HookInvoker.invokeAndContinueUntilValueReceived ' +
            'must be a non-empty String, but %s was given.',
          v,
        );
      expect(throwable('')).to.throw(error('""'));
      expect(throwable(10)).to.throw(error('10'));
      expect(throwable(0)).to.throw(error('0'));
      expect(throwable(true)).to.throw(error('true'));
      expect(throwable(false)).to.throw(error('false'));
      expect(throwable(null)).to.throw(error('null'));
      expect(throwable({})).to.throw(error('Object'));
      expect(throwable([])).to.throw(error('Array'));
      expect(throwable(undefined)).to.throw(error('undefined'));
      throwable(RouterHookType.PRE_HANDLER)();
    });

    it('requires the parameter "hookType" to be a supported hook', function () {
      const s = new HookInvoker();
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        handler: () => undefined,
      });
      const res = createResponseMock();
      Object.values(RouterHookType).forEach(type =>
        s.invokeAndContinueUntilValueReceived(route, type, res),
      );
      const throwable = () =>
        s.invokeAndContinueUntilValueReceived(route, 'unknown', res);
      expect(throwable).to.throw('The hook type "unknown" is not supported.');
    });

    it('requires the parameter "response" to be an instance of ServerResponse', function () {
      const s = new HookInvoker();
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        handler: () => undefined,
      });
      const throwable = v => () =>
        s.invokeAndContinueUntilValueReceived(
          route,
          RouterHookType.PRE_HANDLER,
          v,
        );
      const error = v =>
        format(
          'The parameter "response" of ' +
            'the HookInvoker.invokeAndContinueUntilValueReceived ' +
            'must be a ServerResponse instance, but %s was given.',
          v,
        );
      expect(throwable('str')).to.throw(error('"str"'));
      expect(throwable('')).to.throw(error('""'));
      expect(throwable(10)).to.throw(error('10'));
      expect(throwable(0)).to.throw(error('0'));
      expect(throwable(true)).to.throw(error('true'));
      expect(throwable(false)).to.throw(error('false'));
      expect(throwable(null)).to.throw(error('null'));
      expect(throwable({})).to.throw(error('Object'));
      expect(throwable([])).to.throw(error('Array'));
      expect(throwable(undefined)).to.throw(error('undefined'));
      throwable(createResponseMock())();
    });

    it('invokes global hooks in priority', function () {
      const s = new HookInvoker();
      const order = [];
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
          },
        ],
        handler: () => undefined,
      });
      s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'routeHook1',
        'routeHook2',
      ]);
    });

    it('stops global hooks invocation if any of them returns a value', function () {
      const s = new HookInvoker();
      const order = [];
      const ret = 'OK';
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
        return ret;
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook3');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
          },
        ],
        handler: () => undefined,
      });
      const result = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(result).to.be.eq(ret);
      expect(order).to.be.eql(['globalHook1', 'globalHook2']);
    });

    it('stops route hooks invocation if any of them returns a value', function () {
      const s = new HookInvoker();
      const order = [];
      const ret = 'OK';
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
            return ret;
          },
          () => {
            order.push('routeHook3');
          },
        ],
        handler: () => undefined,
      });
      const result = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(result).to.be.eq(ret);
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'routeHook1',
        'routeHook2',
      ]);
    });

    it('returns the given response and should not call hooks if the response is already sent', function () {
      const s = new HookInvoker();
      const res = createResponseMock();
      res._headersSent = true;
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        throw new Error('Should not be called');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            throw new Error('Should not be called');
          },
        ],
        handler: () => undefined,
      });
      const result = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        res,
      );
      expect(result).to.be.eq(res);
    });

    it('stops global hooks invocation and returns the given response if it is already sent', function () {
      const s = new HookInvoker();
      const order = [];
      const res = createResponseMock();
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
        res._headersSent = true;
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook3');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
          },
        ],
        handler: () => undefined,
      });
      const result = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        res,
      );
      expect(result).to.be.eq(res);
      expect(order).to.be.eql(['globalHook1', 'globalHook2']);
    });

    it('stops route hooks invocation and returns the given response if it is already sent', function () {
      const s = new HookInvoker();
      const order = [];
      const res = createResponseMock();
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
            res._headersSent = true;
          },
          () => {
            order.push('routeHook3');
          },
        ],
        handler: () => undefined,
      });
      const result = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        res,
      );
      expect(result).to.be.eq(res);
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'routeHook1',
        'routeHook2',
      ]);
    });

    it('returns a Promise if any global hook is asynchronous', async function () {
      const s = new HookInvoker();
      const order = [];
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(
        RouterHookType.PRE_HANDLER,
        async () => {
          order.push('globalHook2');
        },
      );
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook3');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
          },
        ],
        handler: () => undefined,
      });
      const promise = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(promise).to.be.instanceof(Promise);
      await expect(promise).to.eventually.be.undefined;
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'globalHook3',
        'routeHook1',
        'routeHook2',
      ]);
    });

    it('returns a Promise if entire global hooks are asynchronous', async function () {
      const s = new HookInvoker();
      const order = [];
      s.getService(HookRegistry).addHook(
        RouterHookType.PRE_HANDLER,
        async () => {
          order.push('globalHook1');
        },
      );
      s.getService(HookRegistry).addHook(
        RouterHookType.PRE_HANDLER,
        async () => {
          order.push('globalHook2');
        },
      );
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          () => {
            order.push('routeHook2');
          },
        ],
        handler: () => undefined,
      });
      const promise = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(promise).to.be.instanceof(Promise);
      await expect(promise).to.eventually.be.undefined;
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'routeHook1',
        'routeHook2',
      ]);
    });

    it('returns a Promise if any route hook is asynchronous', async function () {
      const s = new HookInvoker();
      const order = [];
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          () => {
            order.push('routeHook1');
          },
          async () => {
            order.push('routeHook2');
          },
          () => {
            order.push('routeHook3');
          },
        ],
        handler: () => undefined,
      });
      const promise = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(promise).to.be.instanceof(Promise);
      await expect(promise).to.eventually.be.undefined;
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'routeHook1',
        'routeHook2',
        'routeHook3',
      ]);
    });

    it('returns a Promise if entire route hooks are asynchronous', async function () {
      const s = new HookInvoker();
      const order = [];
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook1');
      });
      s.getService(HookRegistry).addHook(RouterHookType.PRE_HANDLER, () => {
        order.push('globalHook2');
      });
      const route = new Route({
        method: HttpMethod.GET,
        path: ROOT_PATH,
        preHandler: [
          async () => {
            order.push('routeHook1');
          },
          async () => {
            order.push('routeHook2');
          },
        ],
        handler: () => undefined,
      });
      const promise = s.invokeAndContinueUntilValueReceived(
        route,
        RouterHookType.PRE_HANDLER,
        createResponseMock(),
      );
      expect(promise).to.be.instanceof(Promise);
      await expect(promise).to.eventually.be.undefined;
      expect(order).to.be.eql([
        'globalHook1',
        'globalHook2',
        'routeHook1',
        'routeHook2',
      ]);
    });
  });
});