@contrast/route-coverage 1.35.0 → 1.35.2

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

@@ -1,418 +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 express', function () {
-  let core, http, Server, application, Router, Layer, express, fn, 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);
-
-    application = () => application;
-    Router = () => Router;
-    Layer = () => Layer;
-    Layer.handle = sinon.stub();
-
-    express = () => application;
-    framework = 'express';
-
-    Router.stack = [];
-    Router.handle = sinon.stub();
-    Router.use = (prefix, router) => {
-      Router.stack.push({ handle: router, name: 'router', regexp: { source: `\\${prefix}` } });
-    };
-
-    express.application = application;
-    express.application.use = (prefix, router) => {
-      if (router?.use) router.use(prefix, router);
-      return { _router: Router };
-    };
-    express.application._router = Router;
-    express.Router = Router;
-
-    METHODS.forEach((method) => {
-      application[method] = () => {
-        Router.stack.push(Layer);
-        return { _router: Router };
-      };
-      Router[method] = (path, fn) => {
-        Layer.regexp = { source: `\\${path}` };
-        Layer.route = {
-          path,
-          stack: [
-            {
-              method
-            }
-          ],
-          methods: {
-            _all: false
-          }
-        };
-        if (fn) Router.stack.push(Layer);
-        return Router;
-      };
-    });
-    Server = function () { };
-    Server.prototype.listen = sinon.stub();
-    http = {
-      Server,
-      createServer() {
-        return new Server();
-      }
-    };
-
-    fn = sinon.stub();
-
-    core.depHooks.resolve.withArgs({ name: 'express', version: '>=4 <5' }).yields(express);
-    core.depHooks.resolve.withArgs({ name: 'http' }).yields(http);
-
-    require('./express4')(core).install();
-  });
-
-  describe('app', function () {
-    METHODS.forEach((method) => {
-      describe(`${method}`, function () {
-        it('does not report a non-existent 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 method', function () {
-          const app = express();
-          app[method]('/test/route');
-          expect(core.routeCoverage.discover).not.to.have.been.called;
-        });
-
-        it('discovers a route', function () {
-          const app = express();
-          app[method]('/test/route', fn);
-
-          expect(core.routeCoverage.discover).to.have.been.calledWith({
-            signature: `App.${method}('/test/route', [Function])`,
-            url: '/test/route',
-            normalizedUrl: '/test/route',
-            method,
-            framework
-          });
-        });
-
-        it('discovers an array route', function () {
-          const app = express();
-          app[method](['/test/foo', '/test/bar'], fn);
-
-          expect(core.routeCoverage.discover).to.have.been.calledWith({
-            signature: `App.${method}('/[/test/foo,/test/bar]', [Function])`,
-            url: '/[/test/foo,/test/bar]',
-            normalizedUrl: '/[/test/foo,/test/bar]',
-            method,
-            framework
-          });
-        });
-
-        it('discovers a regEx route', function () {
-          const app = express();
-          app[method](/f*o/, fn);
-
-          expect(core.routeCoverage.discover).to.have.been.calledWith({
-            signature: `App.${method}('/{f*o}', [Function])`,
-            url: '/{f*o}',
-            normalizedUrl: '/{f*o}',
-            method,
-            framework
-          });
-        });
-      });
-    });
-
-    it('does not discover and App.use route with no path and no router', function () {
-      const app = express();
-      app.use(fn);
-      expect(core.routeCoverage.discover).not.have.been.called;
-    });
-
-    it('discovers an App.use route', function () {
-      const app = express();
-      app.use('/foo', fn);
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: 'App.use(\'/foo\', [Function])',
-        url: '/foo',
-        normalizedUrl: '/foo',
-        method: 'use',
-        framework
-      });
-    });
-
-    it('discovers an App.use route with a non-string url', function () {
-      const app = express();
-      app.use(['/foo'], fn);
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: 'App.use(\'/[/foo]\', [Function])',
-        url: '/[/foo]',
-        normalizedUrl: '/[/foo]',
-        method: 'use',
-        framework
-      });
-    });
-
-    it('discovers a route with middleware defined in an array', function() {
-      const app = express();
-      app.use('/foo', [fn]);
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: 'App.use(\'/foo\', [Function])',
-        url: '/foo',
-        normalizedUrl: '/foo',
-        method: 'use',
-        framework
-      });
-    });
-
-    it('does not observe a route with an undefined method', function () {
-      const app = express();
-      app.get('/path/to/foo', fn);
-
-      express.Router.handle({
-        originalUrl: '/path/to/foo',
-        route: { path: '/path/to/foo' }
-      });
-      expect(core.routeCoverage.observe).to.not.have.been.called;
-    });
-
-    it('observes a route when a route handler is exercised', function () {
-      const app = express();
-      app.get('/path/to/foo', fn);
-
-      express.Router.stack[0].handle({
-        method: 'GET',
-        originalUrl: '/path/to/foo',
-        route: { path: '/path/to/foo' }
-      });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "App.get('/path/to/foo', [Function])",
-        url: '/path/to/foo',
-        normalizedUrl: '/path/to/foo',
-        method: 'get',
-        framework
-      });
-    });
-
-    it('observes a route with a regExp path', function () {
-      const app = express();
-      app.get(/.*/, fn);
-
-      express.Router.stack[0].handle({
-        method: 'GET',
-        originalUrl: '/path',
-        route: { path: /.*/ }
-      });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "App.get('/{.*}', [Function])",
-        url: '/path',
-        normalizedUrl: '/{.*}',
-        method: 'get',
-        framework
-      });
-    });
-
-    it('observes a route with an Array path', function () {
-      const app = express();
-      app.get(['/test/foo', '/test/bar'], fn);
-
-      express.Router.stack[0].handle({
-        method: 'GET',
-        originalUrl: '/[/test/foo,/test/bar]',
-        route: { path: ['/test/foo', '/test/bar'] }
-      });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "App.get('/[/test/foo,/test/bar]', [Function])",
-        url: '/[/test/foo,/test/bar]',
-        normalizedUrl: '/[/test/foo,/test/bar]',
-        method: 'get',
-        framework
-      });
-    });
-
-    it('updates route prefixes', function () {
-      const app = express();
-      const router = express.Router();
-      router.get('/foo', fn);
-      app.use('/prefix', router);
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "Router.get('/prefix/foo', [Function])",
-        url: '/prefix/foo',
-        normalizedUrl: '/prefix/foo',
-        method: 'get',
-        framework
-      });
-    });
-  });
-
-  describe('router', function () {
-    METHODS.forEach((method) => {
-      describe(`${method}`, function () {
-        it('does not report a non-existent 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('discovers a route', 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', [Function])`,
-            url: '/test/route',
-            normalizedUrl: '/test/route',
-            method,
-            framework
-          });
-        });
-
-        it('discovers an array route', function () {
-          const app = express();
-          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]', [Function])`,
-            url: '/[/test/foo,/test/bar]',
-            normalizedUrl: '/[/test/foo,/test/bar]',
-            method,
-            framework
-          });
-        });
-
-        it('discovers a regEx route', function () {
-          const app = express();
-          const router = express.Router();
-          router[method](/f*o/, fn);
-          app.use(router);
-
-          expect(core.routeCoverage.discover).to.have.been.calledWith({
-            signature: `Router.${method}('/{f*o}', [Function])`,
-            url: '/{f*o}',
-            normalizedUrl: '/{f*o}',
-            method,
-            framework
-          });
-        });
-      });
-    });
-
-    it('does not observe a route with an undefined method', function () {
-      const app = express();
-      const router = express.Router();
-      router.get('/path/to/foo', fn);
-      app.use(router);
-
-      express.Router.handle({
-        originalUrl: '/path/to/foo',
-        route: { path: '/path/to/foo' }
-      });
-      expect(core.routeCoverage.observe).to.not.have.been.called;
-    });
-
-    it('observes a route when a route handler is exercised', function () {
-      const app = express();
-      const router = express.Router();
-      router.get('/path/to/foo', fn);
-      app.use(router);
-
-      express.Router.stack[0].handle({
-        method: 'GET',
-        originalUrl: '/path/to/foo',
-        route: { path: '/path/to/foo' }
-      });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "Router.get('/path/to/foo', [Function])",
-        url: '/path/to/foo',
-        normalizedUrl: '/path/to/foo',
-        method: 'get',
-        framework
-      });
-    });
-
-    it('updates route prefixes on nested router', function () {
-      const app = express();
-      const router = express.Router();
-      router.get('/foo', fn);
-      router.use('/prefix', router);
-      app.use(router);
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "Router.get('/prefix/foo', [Function])",
-        url: '/prefix/foo',
-        normalizedUrl: '/prefix/foo',
-        method: 'get',
-        framework
-      });
-    });
-
-    it('updates route prefixes on a non-nested router', function () {
-      const app = express();
-      const router = express.Router();
-      const router2 = express.Router();
-      router.get('/foo', fn);
-      router2.use('/prefix', router);
-      app.use(router);
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "Router.get('/prefix/foo', [Function])",
-        url: '/prefix/foo',
-        normalizedUrl: '/prefix/foo',
-        method: 'get',
-        framework
-      });
-    });
-
-  });
-});