@contrast/route-coverage 1.35.1 → 1.35.2

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

@@ -1,813 +0,0 @@
-'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
-      });
-    });
-  });
-});