@contrast/route-coverage 1.35.1 → 1.35.2

package/lib/install/fastify.test.js

@@ -1,218 +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 { getFastifyMethods } = require('../utils/methods');
-
-[
-  { version: '>=3 <4.1.0', routeObj: false },
-  { version: '>=4.1.0 <4.4.0', routeObj: true },
-  { version: '>=4.4.0 <5', routeObj: true }
-].forEach(({ version, routeObj }) => {
-  describe(`route-coverage fastify (${version})`, function () {
-    const FASTIFY_METHODS = getFastifyMethods(version);
-    let core, RouteMock, framework, routing, fn;
-
-    function routeOptions(options, fullyDeclared, routeObj) {
-      if (fullyDeclared && routeObj) {
-        return [{ options }];
-      } else if ((fullyDeclared && !routeObj) || (!fullyDeclared && routeObj)) {
-        return [options];
-      } else if (!fullyDeclared && !routeObj) {
-        return Object.values(options);
-      }
-    }
-
-    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);
-      sinon.spy(core.patcher, 'patch');
-
-      RouteMock = {
-        buildRouting: () => ({
-          prepareRoute: sinon.stub(),
-          route: sinon.stub()
-        })
-      };
-
-      framework = 'fastify';
-      core.depHooks.resolve
-        .withArgs({ name: 'fastify', version, file: 'lib/route.js' })
-        .yields(RouteMock);
-
-      require('./fastify')(core).install();
-
-      routing = RouteMock.buildRouting();
-      fn = sinon.stub();
-    });
-
-    [
-      { method: 'prepareRoute', fullyDefined: false },
-      { method: 'route', fullyDefined: true },
-    ].forEach(({ method, fullyDefined }) => {
-      describe(`.${method} base cases`, function() {
-        it('skips instrumenting if nothing is provided', function () {
-          routing[method]();
-          expect(core.routeCoverage.discover).not.to.have.been.called;
-        });
-
-        it('skips instrumenting if there is no method provided', function () {
-          routing[method](...routeOptions({ url: '/test/route', handler: fn }, fullyDefined, routeObj));
-          expect(core.routeCoverage.discover).not.to.have.been.called;
-        });
-
-        it('skips instrumenting if there is no url provided', function () {
-          routing[method](...routeOptions({ method: 'GET', handler: fn }, fullyDefined, routeObj));
-          expect(core.routeCoverage.discover).not.to.have.been.called;
-        });
-
-        it('skips instrumenting if there is no handler is provided', function () {
-          routing[method](...routeOptions({ method: 'GET', url: '/test/route' }, fullyDefined, routeObj));
-          expect(core.routeCoverage.discover).not.to.have.been.called;
-        });
-      });
-    });
-
-    it('discovers a route with a single method', function () {
-      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.get('/test/route', [Function])",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'get',
-        framework
-      });
-      expect(core.routeCoverage.discover).to.have.been.called;
-      expect(core.routeCoverage.discover).to.have.callCount(1);
-    });
-
-    it('discovers a route with a prefixed path', function () {
-      routing[Symbol('fastify.routePrefix')] = '/prefix';
-      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.get('/prefix/test/route', [Function])",
-        url: '/prefix/test/route',
-        normalizedUrl: '/prefix/test/route',
-        method: 'get',
-        framework
-      });
-      expect(core.routeCoverage.discover).to.have.been.called;
-      expect(core.routeCoverage.discover).to.have.callCount(1);
-    });
-
-    it('discovers a fully declared (.route) with a prefixed path', function () {
-      routing[Symbol('fastify.routePrefix')] = '/prefix';
-      routing.route(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, true, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.route({ method: 'get', url: '/prefix/test/route', handler: [Function] })",
-        url: '/prefix/test/route',
-        normalizedUrl: '/prefix/test/route',
-        method: 'get',
-        framework
-      });
-      expect(core.routeCoverage.discover).to.have.been.called;
-      expect(core.routeCoverage.discover).to.have.callCount(1);
-    });
-
-    it('discovers a fully declared (.route) route with a single method', function () {
-      routing.route(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, true, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.route({ method: 'get', url: '/test/route', handler: [Function] })",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'get',
-        framework
-      });
-      expect(core.routeCoverage.discover).to.have.been.called;
-      expect(core.routeCoverage.discover).to.have.callCount(1);
-    });
-
-    it('discovers a route with multiple methods', function () {
-      routing.prepareRoute(...routeOptions({ method: ['GET', 'POST'], url: '/test/route', handler: fn }, false, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.get('/test/route', [Function])",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'get',
-        framework
-      });
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.post('/test/route', [Function])",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'post',
-        framework
-      });
-
-      expect(core.routeCoverage.discover).to.have.callCount(2);
-    });
-
-    it('discovers a route with all methods', function () {
-      routing.prepareRoute(...routeOptions({ method: FASTIFY_METHODS, url: '/test/route', handler: fn }, false, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.all('/test/route', [Function])",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'all',
-        framework
-      });
-    });
-
-    it('discovers a fully declared route (.route) with multiple methods', function () {
-      routing.route(...routeOptions({ method: ['GET', 'POST'], url: '/test/route', handler: fn }, true, routeObj));
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.route({ method: 'get', url: '/test/route', handler: [Function] })",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'get',
-        framework
-      });
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "fastify.route({ method: 'post', url: '/test/route', handler: [Function] })",
-        url: '/test/route',
-        normalizedUrl: '/test/route',
-        method: 'post',
-        framework
-      });
-
-      expect(core.routeCoverage.discover).to.have.callCount(2);
-    });
-
-    it('observes a route when the route handler is called', function () {
-      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
-      const patchedFn = core.patcher.patch.getCall(3).returnValue;
-      const handler = routeObj ? patchedFn.handler : patchedFn;
-      handler({ raw: { method: 'GET' }, url: '/test/route' });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "fastify.get('/test/route', [Function])",
-        url: '/test/route',
-        method: 'get',
-        normalizedUrl: '/test/route',
-        framework: 'fastify'
-      });
-    });
-
-    it('removes query string from url before reporting observation', function () {
-      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
-      const patchedFn = core.patcher.patch.getCall(3).returnValue;
-      const handler = routeObj ? patchedFn.handler : patchedFn;
-      handler({ raw: { method: 'GET' }, url: '/test/route' });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "fastify.get('/test/route', [Function])",
-        url: '/test/route',
-        method: 'get',
-        normalizedUrl: '/test/route',
-        framework: 'fastify'
-      });
-    });
-  });
-});

package/lib/install/graphql.test.js

@@ -1,175 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const sinon = require('sinon');
-const { initCoreFixture } = require('@contrast/test/fixtures');
-
-describe('route-coverage graphql', function () {
-  let core;
-  let simulateRequestScope;
-  let MockSchema;
-
-  beforeEach(function () {
-    ({ core, simulateRequestScope } = initCoreFixture());
-    require('..')(core);
-    sinon.spy(core.routeCoverage, 'discover');
-    sinon.spy(core.routeCoverage, 'observe');
-
-    const xport = {
-      GraphQLSchema: class GraphQLSchema {
-        constructor() {}
-      }
-    };
-
-    core.depHooks.resolve.withArgs({ name: 'graphql', version: '>=14 <17', file: './type/schema.js' }).yields(xport);
-    require('./graphql')(core).install();
-    MockSchema = xport.GraphQLSchema;
-  });
-
-  it('reports discovery and observation by instrumenting config object passed to GraphQLSchema constructor', function () {
-    const config = {
-      query: {
-        name: 'Query',
-        _fields: {
-          getThis: {
-            name: 'getThis',
-            args: [{
-              name: 'id',
-              type: class GetThisType {},
-            }],
-            resolve() {},
-          },
-          getThat: {
-            name: 'getThat',
-            resolve() {},
-          },
-        }
-      },
-      mutation: {
-        name: 'Mutation',
-        _fields: {
-          createThis: {
-            name: 'createThis',
-            args: [{
-              name: 'id',
-              type: class CreateThisType {},
-            }],
-            resolve() {},
-          },
-          updateThat: {
-            name: 'updateThat',
-            resolve() {},
-          }
-        }
-      }
-    };
-    new MockSchema(config);
-
-    [
-      {
-        method: 'get',
-        normalizedUrl: '/Query/getThis/{id}',
-        signature: 'GraphQL Query getThis(id: GetThisType)',
-        framework: 'graphql'
-      },
-      {
-        method: 'post',
-        normalizedUrl: '/Query/getThis/{id}',
-        signature: 'GraphQL Query getThis(id: GetThisType)',
-        framework: 'graphql'
-      },
-      {
-        method: 'get',
-        normalizedUrl: '/Query/getThat',
-        signature: 'GraphQL Query getThat',
-        framework: 'graphql'
-      },
-      {
-        method: 'post',
-        normalizedUrl: '/Query/getThat',
-        signature: 'GraphQL Query getThat',
-        framework: 'graphql'
-      },
-      {
-        method: 'get',
-        normalizedUrl: '/Mutation/createThis/{id}',
-        signature: 'GraphQL Mutation createThis(id: CreateThisType)',
-        framework: 'graphql'
-      },
-
-      {
-        method: 'post',
-        normalizedUrl: '/Mutation/createThis/{id}',
-        signature: 'GraphQL Mutation createThis(id: CreateThisType)',
-        framework: 'graphql'
-      },
-      {
-        method: 'get',
-        normalizedUrl: '/Mutation/updateThat',
-        signature: 'GraphQL Mutation updateThat',
-        framework: 'graphql'
-      },
-      {
-        method: 'post',
-        normalizedUrl: '/Mutation/updateThat',
-        signature: 'GraphQL Mutation updateThat',
-        framework: 'graphql'
-      }
-    ].forEach((discovery) => {
-      try {
-        expect(core.routeCoverage.discover).to.have.been.calledWithMatch(discovery);
-      } catch (err) {
-        console.log('not reported:', discovery);
-        console.log(core.routeCoverage.discover.getCalls().map((c) => c.args[0]));
-        throw err;
-      }
-    });
-
-    simulateRequestScope(() => {
-      // exercise resolvers to trigger observation
-      config.query._fields.getThis.resolve();
-      config.query._fields.getThat.resolve();
-      config.mutation._fields.createThis.resolve();
-      config.mutation._fields.updateThat.resolve();
-
-      [
-        {
-          method: 'get',
-          normalizedUrl: '/Query/getThis/{id}',
-          signature: 'GraphQL Query getThis(id: GetThisType)',
-          url: '/Query/getThis/{id}',
-          framework: 'graphql'
-        },
-        {
-          method: 'get',
-          normalizedUrl: '/Query/getThat',
-          signature: 'GraphQL Query getThat',
-          url: '/Query/getThat',
-          framework: 'graphql'
-        },
-        {
-          method: 'get',
-          normalizedUrl: '/Mutation/createThis/{id}',
-          signature: 'GraphQL Mutation createThis(id: CreateThisType)',
-          url: '/Mutation/createThis/{id}',
-          framework: 'graphql'
-        },
-        {
-          method: 'get',
-          normalizedUrl: '/Mutation/updateThat',
-          signature: 'GraphQL Mutation updateThat',
-          url: '/Mutation/updateThat',
-          framework: 'graphql'
-        }
-      ].forEach((observation) => {
-        try {
-          expect(core.routeCoverage.observe).to.have.been.calledWithMatch(observation);
-        } catch (err) {
-          console.log('not reported:', observation);
-          console.log(core.routeCoverage.observe.getCalls().map((c) => c.args[0]));
-          throw err;
-        }
-      });
-    });
-  });
-});

package/lib/install/hapi.test.js

@@ -1,127 +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');
-
-describe('route-coverage hapi', function () {
-  let core, route, _core, hapi, 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);
-
-    route = {
-      settings: {
-        handler: sinon.stub()
-      }
-    };
-
-    _core = {
-      router: {
-        add() {
-          return { route };
-        }
-      }
-    };
-
-    hapi = {
-      server() {
-        return { _core };
-      },
-      Server() {
-        return { _core };
-      }
-    };
-    framework = 'hapi';
-
-    core.depHooks.resolve.withArgs({ name: '@hapi/hapi', version: '>=18 <22' }).yields(hapi);
-    require('./hapi')(core).install();
-  });
-
-
-  ['server', 'Server'].forEach((server) => {
-
-    it('does not report a non-existent route', function () {
-      const hapiServer = hapi[server]();
-      hapiServer._core.router.add();
-      expect(core.routeCoverage.discover).not.to.have.been.called;
-    });
-
-    it('does not report a route missing a method', function () {
-      const hapiServer = hapi[server]();
-      hapiServer._core.router.add({ path: '/foo' });
-      expect(core.routeCoverage.discover).not.to.have.been.called;
-    });
-
-    it('does not report a route missing a path', function () {
-      const hapiServer = hapi[server]();
-      hapiServer._core.router.add({ method: 'GET' });
-      expect(core.routeCoverage.discover).not.to.have.been.called;
-    });
-
-    it('discovers a route with a single method', function () {
-      const hapiServer = hapi[server]();
-      hapiServer._core.router.add({ method: 'GET', path: '/foo' });
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "server.route({ method: 'get', path: '/foo', handler: [Function] })",
-        url: '/foo',
-        normalizedUrl: '/foo',
-        method: 'get',
-        framework
-      });
-    });
-
-    it('discovers a route with multiple methods', function () {
-      const hapiServer = hapi[server]();
-      hapiServer._core.router.add({ method: ['GET', 'PUT'], path: '/foo' });
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "server.route({ method: 'get', path: '/foo', handler: [Function] })",
-        url: '/foo',
-        normalizedUrl: '/foo',
-        method: 'get',
-        framework
-      });
-
-      expect(core.routeCoverage.discover).to.have.been.calledWith({
-        signature: "server.route({ method: 'put', path: '/foo', handler: [Function] })",
-        url: '/foo',
-        normalizedUrl: '/foo',
-        method: 'put',
-        framework
-      });
-    });
-
-    it('observes a route when a route handler is exercised', async function () {
-      const hapiServer = hapi[server]();
-      const { route } = hapiServer._core.router.add({ method: 'get', path: '/foo' });
-      route.settings.handler({ method: 'get', path: '/foo', route: { path: '/foo' } });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "server.route({ method: 'get', path: '/foo', handler: [Function] })",
-        url: '/foo',
-        normalizedUrl: '/foo',
-        method: 'get'
-      });
-    });
-
-    it('observes a route when a route contains parameters', async function () {
-      const hapiServer = hapi[server]();
-      const { route } = hapiServer._core.router.add({ method: 'get', path: '/foo/{id}' });
-      route.settings.handler({ method: 'get', path: '/foo/1', route: { path: '/foo/{id}' } });
-      expect(core.routeCoverage.observe).to.have.been.calledWith({
-        signature: "server.route({ method: 'get', path: '/foo/{id}', handler: [Function] })",
-        url: '/foo/1',
-        normalizedUrl: '/foo/{id}',
-        method: 'get'
-      });
-    });
-  });
-});

package/lib/install/koa.test.js

@@ -1,152 +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 } = require('../utils/methods');
-
-describe('route-coverage koa', function () {
-  let core, Router, framework, Koa, app, handlerFn;
-
-  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 = 'koa';
-    Router = function Router() { };
-    Router.router = {
-      stack: []
-    };
-
-    handlerFn = sinon.stub();
-    Router.prototype.use = (path, fn) => Router.router.stack.push({ methods: [], path, stack: [fn] });
-    Router.prototype.get = (path, fn) => Router.router.stack.push({ methods: ['GET'], path, stack: [fn] });
-    Router.prototype.all = (path, fn) => Router.router.stack.push({ methods: METHODS, path, stack: [fn] });
-    Router.prototype.routes = () => Router;
-
-    Koa = function() {};
-    Koa.prototype.use = sinon.stub();
-    core.depHooks.resolve.withArgs({ name: 'koa', version: '>=2.3.0 <3' }).yields(Koa);
-    require('./koa')(core).install();
-  });
-
-  it('does not report when called with nothing', function () {
-    app = new Koa();
-    app.use();
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('does not report when called with non-router', function () {
-    app = new Koa();
-    app.use({ not: 'a router' });
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('does not report unmounted routes', function () {
-    const router = new Router();
-    router.get('/test/route', handlerFn);
-
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('does not report a non-existent route', function () {
-    const router = new Router();
-    router.get();
-
-    app = new Koa();
-    app.use(router.routes());
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('does not report when path is an array', function () {
-    const router = new Router();
-    router.get(['/test/route'], handlerFn);
-
-    app = new Koa();
-    app.use(router.routes());
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('discovers a route', function () {
-    const router = new Router();
-    router.get('/test/route', handlerFn);
-
-    app = new Koa();
-    app.use(router.routes());
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "Router.get('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'get',
-      framework
-    });
-  });
-
-  it('discovers a .use route', function () {
-    const router = new Router();
-    router.use('/test/route', handlerFn);
-
-    app = new Koa();
-    app.use(router.routes());
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "Router.use('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'use',
-      framework
-    });
-  });
-
-  it('discovers a .all route', function () {
-    const router = new Router();
-    router.all('/test/route', handlerFn);
-
-    app = new Koa();
-    app.use(router.routes());
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "Router.all('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'all',
-      framework
-    });
-  });
-
-  it('does not observe a route without a valid request', async function () {
-    const router = new Router();
-    router.get('/test/route', handlerFn);
-
-    app = new Koa();
-    app.use(router.routes());
-
-    Router.router.stack[0].stack[0]({});
-    expect(core.routeCoverage.observe).to.not.have.been.called;
-  });
-
-  it('observes a route when a route handler is exercised', async function () {
-    const router = new Router();
-    router.get('/test/route', handlerFn);
-
-    app = new Koa();
-    app.use(router.routes());
-
-    const request = {
-      url: '/test/route',
-      method: 'get'
-    };
-    Router.router.stack[0].stack[0]({ request });
-    expect(core.routeCoverage.observe).to.have.been.calledWith({
-      signature: "Router.get('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'get',
-      framework: 'koa'
-    });
-  });
-});