@contrast/route-coverage 1.33.0 → 1.35.0

package/lib/install/express/express5.test.js

@@ -0,0 +1,813 @@
+'use strict';
+
+const { expect } = require('chai');
+const sinon = require('sinon');
+const scopes = require('@contrast/scopes');
+const patcher = require('@contrast/patcher');
+const mocks = require('@contrast/test/mocks');
+
+const METHODS = [
+  'all',
+  'get',
+  'post',
+  'put',
+  'delete',
+  'patch',
+  'options',
+  'head',
+];
+
+describe('route-coverage express5', function () {
+  let core, application, Router, express, framework;
+
+  beforeEach(function () {
+    core = mocks.core();
+    core.logger = mocks.logger();
+    core.routeCoverage = mocks.routeCoverage();
+    core.scopes = scopes(core);
+    core.depHooks = mocks.depHooks();
+    core.patcher = patcher(core);
+
+    framework = 'express';
+    application = {};
+    Router = () => Router.prototype;
+    Router.prototype = {};
+    METHODS.forEach((method) => {
+      application[method] = sinon.stub();
+      Router.prototype[method] = sinon.stub();
+    });
+    application.use = sinon.stub();
+    Router.prototype.use = sinon.stub();
+    Router.prototype.name = 'Router';
+    express = () => application;
+    express.application = application;
+    express.Router = Router;
+
+    sinon.spy(core.patcher, 'patch');
+    core.depHooks.resolve.withArgs({ name: 'express', version: '5' }).yields(express);
+
+    require('./express5')(core).install();
+  });
+
+  describe('app', function () {
+    METHODS.forEach((method) => {
+      describe(`${method}`, function () {
+
+        it('does not report an empty route', function () {
+          const app = express();
+          app[method]();
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report an invalid route', function () {
+          const app = express();
+          app[method](42);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report a route missing a handler', function () {
+          const app = express();
+          app[method]('/test/route');
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report a route with an invalid handler', function () {
+          const app = express();
+          app[method]('/test/route', {});
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report an empty path', function () {
+          const fn = function() {};
+          const app = express();
+          app[method]('', fn);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('discovers a route', function () {
+          const fn = function() {};
+          const app = express();
+          app[method]('/test/route', fn);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('removes a trailing slash from a route', function () {
+          const fn = function() {};
+          const app = express();
+          app[method]('/test/route/', fn);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('discovers a route with an anonymous function handler', function () {
+          const app = express();
+          app[method]('/test/route', () => {});
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', (anonymous express5.test.js 116:37))`, //TODO make consistent
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('discovers an array route', function () {
+          const app = express();
+          const fn = function() {};
+          app[method](['/test/foo', '/test/bar'], fn);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/[/test/foo,/test/bar]', fn)`,
+            url: '/[/test/foo,/test/bar]',
+            normalizedUrl: '/[/test/foo,/test/bar]',
+            method,
+            framework
+          });
+        });
+
+        it('discovers a route for each handler', function () {
+          const fn1 = function() {};
+          const fn2 = function() {};
+          const app = express();
+          app[method]('/test/route', fn1, fn2);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('discovers a route for each handler in an array', function () {
+          const fn1 = function() {};
+          const fn2 = function() {};
+          const app = express();
+          app[method]('/test/route', [fn1, fn2]);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('observes a route when a handler is exercised', function () {
+          const app = express();
+          const fn = function() {};
+          core.patcher.patch.resetHistory();
+          app[method]('/test/route', fn);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('observes an array route', function () {
+          const app = express();
+          const fn = function() {};
+          core.patcher.patch.resetHistory();
+          app[method](['/test/route', '/test/route2'], fn);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `app.${method}('/[/test/route,/test/route2]', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/[/test/route,/test/route2]',
+            method,
+            framework
+          });
+        });
+
+        it('observes a route when only one handler is exercised', function () {
+          const app = express();
+          const fn1 = function() {};
+          const fn2 = function() {};
+          core.patcher.patch.resetHistory();
+          app[method]('/test/route', fn1, fn2);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.observe).not.to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('observes a route when multiple handlers are exercised', function () {
+          const app = express();
+          const fn1 = function() {};
+          const fn2 = function() {};
+          core.patcher.patch.resetHistory();
+          app[method]('/test/route', fn1, fn2);
+
+          const patchedFn1 = core.patcher.patch.getCall(0).returnValue;
+          const patchedFn2 = core.patcher.patch.getCall(1).returnValue;
+
+          patchedFn1({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          patchedFn2({
+            method,
+            originalUrl: '/test/route?input=bar'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `app.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+      });
+    });
+
+    it('does not discover and App.use route with no path and no router', function () {
+      const app = express();
+      const fn = function() {};
+      app.use(fn);
+      expect(core.routeCoverage.discover).not.to.have.been.called;
+    });
+
+    it('discovers a route when declared with app.use', function () {
+      const app = express();
+      const fn = function() {};
+      app.use('/test/route', fn);
+
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'app.use(\'/test/route\', fn)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'use',
+        framework
+      });
+    });
+
+    it('discovers a route with an array path when declared with app.use', function () {
+      const app = express();
+      const fn = function() {};
+      app.use(['/test/route', '/test/route2'], fn);
+
+      //TODO add space
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'app.use(\'/[/test/route,/test/route2]\', fn)',
+        url: '/[/test/route,/test/route2]',
+        normalizedUrl: '/[/test/route,/test/route2]',
+        method: 'use',
+        framework
+      });
+    });
+
+    it('discovers a route for each handler for app.use', function () {
+      const app = express();
+      const fn1 = function() {};
+      const fn2 = function() {};
+      app.use('/test/route', fn1, fn2);
+
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'app.use(\'/test/route\', fn1)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'use',
+        framework
+      });
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'app.use(\'/test/route\', fn2)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'use',
+        framework
+      });
+    });
+
+    it('observes a route when app.use handler exercised', function () {
+      const app = express();
+      const fn = function() {};
+      core.patcher.patch.resetHistory();
+      app.use('/test/route', fn);
+
+      const patchedFn = core.patcher.patch.getCall(0).returnValue;
+      patchedFn({
+        method: 'GET',
+        originalUrl: '/test/route?input=foo'
+      });
+
+      expect(core.routeCoverage.observe).to.have.been.calledWith({
+        signature: 'app.use(\'/test/route\', fn)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'get',
+        framework
+      });
+    });
+  });
+
+  describe('router', function () {
+    METHODS.forEach((method) => {
+      describe(`${method}`, function () {
+        it('does not report an empty route', function () {
+          const app = express();
+          const Router = express.Router();
+          Router[method]();
+          app.use(Router);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report an invalid route', function () {
+          const app = express();
+          const Router = express.Router();
+          Router[method](42);
+          app.use(Router);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report a route missing a handler', function () {
+          const app = express();
+          const Router = express.Router();
+          Router[method]('/test/route');
+          app.use(Router);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report a route with an invalid handler', function () {
+          const app = express();
+          const Router = express.Router();
+          Router[method]('/test/route', {});
+          app.use(Router);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('does not report an empty path', function () {
+          const fn = function() {};
+          const app = express();
+          const Router = express.Router();
+          Router[method]('', fn);
+          app.use(Router);
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('discovers a route', function () {
+          const fn = function() {};
+          const app = express();
+          const Router = express.Router();
+          Router[method]('/test/route', fn);
+
+          app.use(Router);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('discovers a route with an anonymous function handler', function () {
+          const app = express();
+          const Router = express.Router();
+          Router[method]('/test/route', () => {});
+
+          app.use(Router);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', (anonymous express5.test.js 439:40))`, //TODO make consistent
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('discovers an array route', function () {
+          const app = express();
+          const fn = function() {};
+          const Router = express.Router();
+          Router[method](['/test/foo', '/test/bar'], fn);
+
+          app.use(Router);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/[/test/foo,/test/bar]', fn)`,
+            url: '/[/test/foo,/test/bar]',
+            normalizedUrl: '/[/test/foo,/test/bar]',
+            method,
+            framework
+          });
+        });
+
+        it('discovers a route for each handler', function () {
+          const fn1 = function() {};
+          const fn2 = function() {};
+          const app = express();
+          const Router = express.Router();
+          Router[method]('/test/route', fn1, fn2);
+
+          app.use(Router);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('discovers a route for each handler in an array', function () {
+          const fn1 = function() {};
+          const fn2 = function() {};
+          const app = express();
+          const Router = express.Router();
+          Router[method]('/test/route', [fn1, fn2]);
+
+          app.use(Router);
+
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.discover).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('observes a route when a handler is exercised', function () {
+          const app = express();
+          const fn = function() {};
+          const Router = express.Router();
+          core.patcher.patch.resetHistory();
+          Router[method]('/test/route', fn);
+
+          app.use(Router);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('observes an array route', function () {
+          const app = express();
+          const fn = function() {};
+          const Router = express.Router();
+          core.patcher.patch.resetHistory();
+          Router[method](['/test/route', '/test/route2'], fn);
+
+          app.use(Router);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `router.${method}('/[/test/route,/test/route2]', fn)`,
+            url: '/test/route',
+            normalizedUrl: '/[/test/route,/test/route2]',
+            method,
+            framework
+          });
+        });
+
+        it('observes an updated array route', function () {
+          const app = express();
+          const fn = function() {};
+          const Router = express.Router();
+          core.patcher.patch.resetHistory();
+          Router[method](['/test/route', '/test/route2'], fn);
+
+          app.use('/p1', Router);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/p1/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `router.${method}('/p1/[/test/route,/test/route2]', fn)`,
+            url: '/p1/test/route',
+            normalizedUrl: '/p1/[/test/route,/test/route2]',
+            method,
+            framework
+          });
+        });
+
+        it('observes a route when only one handler is exercised', function () {
+          const app = express();
+          const fn1 = function() {};
+          const fn2 = function() {};
+          const Router = express.Router();
+          core.patcher.patch.resetHistory();
+          Router[method]('/test/route', fn1, fn2);
+
+          app.use(Router);
+
+          const patchedFn = core.patcher.patch.getCall(0).returnValue;
+          patchedFn({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.observe).not.to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+
+        it('observes a route when multiple handlers are exercised', function () {
+          const app = express();
+          const fn1 = function() {};
+          const fn2 = function() {};
+          const Router = express.Router();
+          core.patcher.patch.resetHistory();
+          Router[method]('/test/route', fn1, fn2);
+
+          app.use(Router);
+
+          const patchedFn1 = core.patcher.patch.getCall(0).returnValue;
+          const patchedFn2 = core.patcher.patch.getCall(1).returnValue;
+
+          patchedFn1({
+            method,
+            originalUrl: '/test/route?input=foo'
+          });
+
+          patchedFn2({
+            method,
+            originalUrl: '/test/route?input=bar'
+          });
+
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn1)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+          expect(core.routeCoverage.observe).to.have.been.calledWith({
+            signature: `router.${method}('/test/route', fn2)`,
+            url: '/test/route',
+            normalizedUrl: '/test/route',
+            method,
+            framework
+          });
+        });
+      });
+    });
+
+    it('does not discover and router.use route with no path and no router', function () {
+      const app = express();
+      const fn = function() {};
+      const Router = express.Router();
+
+      Router.use(fn);
+      app.use(Router);
+      expect(core.routeCoverage.discover).not.to.have.been.called;
+    });
+
+    it('discovers a route when declared with router.use', function () {
+      const app = express();
+      const fn = function() {};
+      const Router = express.Router();
+      Router.use('/test/route', fn);
+      app.use(Router);
+
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'router.use(\'/test/route\', fn)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'use',
+        framework
+      });
+    });
+
+    it('discovers a route with an array path when declared with router.use', function () {
+      const app = express();
+      const fn = function() {};
+      const Router = express.Router();
+      Router.use(['/test/route', '/test/route2'], fn);
+      app.use(Router);
+
+      //TODO add space
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'router.use(\'/[/test/route,/test/route2]\', fn)',
+        url: '/[/test/route,/test/route2]',
+        normalizedUrl: '/[/test/route,/test/route2]',
+        method: 'use',
+        framework
+      });
+    });
+
+    it('discovers a route for each handler for router.use', function () {
+      const app = express();
+      const fn1 = function() {};
+      const fn2 = function() {};
+      const Router = express.Router();
+      Router.use('/test/route', fn1, fn2);
+      app.use(Router);
+
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'router.use(\'/test/route\', fn1)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'use',
+        framework
+      });
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'router.use(\'/test/route\', fn2)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'use',
+        framework
+      });
+    });
+
+    it('observes a route when router.use handler exercised', function () {
+      const app = express();
+      const fn = function() {};
+      core.patcher.patch.resetHistory();
+      const Router = express.Router();
+      Router.use('/test/route', fn);
+      app.use(Router);
+
+      const patchedFn = core.patcher.patch.getCall(0).returnValue;
+      patchedFn({
+        method: 'GET',
+        originalUrl: '/test/route?input=foo'
+      });
+
+      expect(core.routeCoverage.observe).to.have.been.calledWith({
+        signature: 'router.use(\'/test/route\', fn)',
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'get',
+        framework
+      });
+    });
+
+    it('updates a route when prefix is declared', function () {
+      const app = express();
+      const fn = function() {};
+      const Router = express.Router();
+      const Router2 = { ...Router };
+      Router.get('/test/route', fn);
+      Router2.use('/p1', Router);
+      app.use(Router2);
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'router.get(\'/p1/test/route\', fn)',
+        url: '/p1/test/route',
+        normalizedUrl: '/p1/test/route',
+        method: 'get',
+        framework
+      });
+    });
+
+    it('correctly formats an updated route when router mounted on itself', function () {
+      const app = express();
+      const fn = function() {};
+      const Router = express.Router();
+      Router.get('/test/route', fn);
+      Router.use('/p1', Router);
+      app.use(Router);
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: 'router.get(\'/*p1/test/route\', fn)',
+        url: '/*p1/test/route',
+        normalizedUrl: '/*p1/test/route',
+        method: 'get',
+        framework
+      });
+    });
+
+    it('observes an updated route', function () {
+      const app = express();
+      const fn = function() {};
+      const Router = express.Router();
+      const Router2 = { ...Router };
+      core.patcher.patch.resetHistory();
+      Router.get('/test/route', fn);
+      Router2.use('/p1', Router);
+      app.use(Router2);
+
+      const patchedFn = core.patcher.patch.getCall(0).returnValue;
+      patchedFn({
+        method: 'GET',
+        originalUrl: '/p1/test/route?input=foo'
+      });
+
+      expect(core.routeCoverage.observe).to.have.been.calledWith({
+        signature: 'router.get(\'/p1/test/route\', fn)',
+        url: '/p1/test/route',
+        normalizedUrl: '/p1/test/route',
+        method: 'get',
+        framework
+      });
+    });
+  });
+});