@contrast/protect 1.53.1 → 1.54.1

package/lib/input-analysis/index.test.js

@@ -1,45 +0,0 @@
-'use strict';
-
-const sinon = require('sinon');
-const { expect } = require('chai');
-const proxyquire = require('proxyquire');
-const mocks = require('@contrast/test/mocks');
-
-describe('protect input-analysis', function () {
-  let modulesMock, installStub, core, inputAnalysis;
-  beforeEach(function () {
-    installStub = sinon.stub();
-    modulesMock = (propertyName) => function (core) {
-      if (propertyName) {
-        core.protect.inputAnalysis[propertyName] = { install: installStub };
-      }
-    };
-    core = mocks.core();
-    core.depHooks = mocks.depHooks();
-    core.protect = mocks.protect();
-
-    inputAnalysis = proxyquire('.', {
-      './handlers': modulesMock,
-      './install/http': modulesMock('httpInstrumentation'),
-      './install/fastify': modulesMock('fastify3Instrumentation'),
-      './install/koa2': modulesMock('koa2Instrumentation'),
-      './install/koa-body5': modulesMock('koaBody5Instrumentation'),
-      './install/koa-bodyparser4': modulesMock('koaBodyparser4Instrumentation'),
-      './install/express': modulesMock('expressInstrumentation'),
-      './install/body-parser1': modulesMock('bodyParser1Instrumentation'),
-      './install/cookie-parser1': modulesMock('cookieParser1Instrumentation'),
-      './install/formidable1': modulesMock('formidable1Instrumentation'),
-      './install/multer1': modulesMock('multer1Instrumentation'),
-      './install/qs6': modulesMock('qs6Instrumentation'),
-      './install/restify': modulesMock('restifyInstrumentation'),
-      './install/universal-cookie4': modulesMock('universalCookie4Instrumentation'),
-      './install/hapi': modulesMock('hapiInstrumentation'),
-      // Total of 15 modules required - 1 handlers and 14 modules to be installed
-    });
-  });
-
-  it('calls the install method on all hooks', function () {
-    inputAnalysis(core).install();
-    expect(installStub).to.have.callCount(14);
-  });
-});

package/lib/input-analysis/install/body-parser1.test.js

@@ -1,134 +0,0 @@
-'use strict';
-
-const sinon = require('sinon');
-const { expect } = require('chai');
-const scopes = require('@contrast/scopes');
-const mocks = require('@contrast/test/mocks');
-const SecurityException = require('../../security-exception');
-const secEx = SecurityException.create();
-const bodyParserInstr = require('./body-parser1');
-
-describe('protect input-analysis body-parser v1.x', function () {
-  let core, inputAnalysis, bodyParserMock, patchedBodyParser, body, nextStub;
-
-
-  beforeEach(function () {
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.scopes = scopes(core);
-    core.protect = mocks.protect();
-    require('../../get-source-context')(core);
-    core.depHooks = mocks.depHooks();
-
-    inputAnalysis = core.protect.inputAnalysis;
-    body = { parameter: 'parsed' };
-    const bodyParserFn = (payload) => (req, res, next) => {
-      if (payload) {
-        req.body = payload;
-      }
-
-      next();
-    };
-    bodyParserMock = (payload) => bodyParserFn(payload);
-    nextStub = sinon.stub();
-
-    ['json', 'raw', 'text', 'urlencoded'].forEach((property) => {
-      bodyParserMock[property] = (payload) => (req, res, next) => {
-        if (payload) {
-          req.body = payload;
-        }
-        next();
-      };
-    });
-
-    bodyParserInstr(core).install();
-    core.depHooks.resolve.yield(bodyParserMock);
-    patchedBodyParser = core.depHooks.resolve.yield(bodyParserMock)[0];
-  });
-
-  it('calls `.handleParsedBody` when parsing is successful and in right context', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser(body)({}, {}, nextStub);
-    });
-
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser.json()({ body }, {}, nextStub);
-    });
-
-    expect(inputAnalysis.handleParsedBody).to.have.been.calledTwice;
-    expect(inputAnalysis.handleParsedBody).to.have.been.calledWithMatch({ parsedBody: body }, body);
-    expect(nextStub).to.have.been.calledTwice;
-  });
-
-  it('calls `.handleParsedBody` when parsing is successful, in right context with the body parsed by JSON.parse when bodyParser.text method is used', function () {
-
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser.text()({ body: JSON.stringify(body) }, {}, nextStub);
-    });
-
-    expect(inputAnalysis.handleParsedBody).to.have.been.calledOnceWith({ parsedBody: body }, body);
-    expect(nextStub).to.have.been.calledOnce;
-  });
-
-  it('logs an error if parsing the body in case of bodyParser.text throws an error', function () {
-
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser.text()({ body: 'not-a-valid-JSON' }, {}, nextStub);
-    });
-
-    expect(core.logger.error).to.have.been.calledOnceWithExactly(sinon.match.any, 'Error parsing with bodyParser.text()');
-    expect(nextStub).to.have.been.calledOnce;
-  });
-
-  it('does not call `.handleParsedBody` when not in context', function () {
-    core.scopes.sources.run({}, () => {
-      patchedBodyParser(body)({}, {}, nextStub);
-    });
-
-    core.scopes.sources.run({}, () => {
-      patchedBodyParser.json()({ body }, {}, nextStub);
-    });
-
-    expect(inputAnalysis.handleParsedBody).not.to.have.been.called;
-    expect(nextStub).to.have.been.calledTwice;
-  });
-
-  it('does not call `.handleParsedBody` when `body-parser` does not return a result', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser(null);
-    });
-
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser.json()({}, {}, nextStub);
-    });
-
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser.json()({ body: {} }, {}, nextStub);
-    });
-
-    expect(inputAnalysis.handleParsedBody).not.to.have.been.called;
-    expect(nextStub).to.have.been.calledTwice;
-  });
-
-  it('handles a case with SecurityException from `.handleParsedBody`', function () {
-    inputAnalysis.handleParsedBody.throws(secEx);
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser(body)({}, {}, nextStub);
-    });
-
-    expect(nextStub).to.have.been.calledWith(secEx);
-  });
-
-  it('handles a case with an error in the input analysis from `.handleParsedBody`', function () {
-    const err = new Error('Input Analysis Error');
-
-    inputAnalysis.handleParsedBody.throws(err);
-    core.scopes.sources.run({ protect: {} }, () => {
-      patchedBodyParser(body)({}, {}, nextStub);
-    });
-
-    expect(core.logger.error).to.have.been.calledWith({ err }, 'Unexpected error during input analysis');
-    expect(nextStub).to.have.been.calledOnce;
-    expect(nextStub).not.to.have.been.calledWith(err);
-  });
-});

package/lib/input-analysis/install/busboy1.test.js

@@ -1,81 +0,0 @@
-'use strict';
-
-const sinon = require('sinon');
-const { expect } = require('chai');
-const scopes = require('@contrast/scopes');
-const patcher = require('@contrast/patcher');
-const mocks = require('@contrast/test/mocks');
-const busboyInstr = require('./busboy1');
-
-describe('protect input-analysis busboy v1.x', function () {
-  let core, inputAnalysis, mockBusboy;
-
-  beforeEach(function () {
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.scopes = scopes(core);
-    core.protect = mocks.protect();
-    require('../../get-source-context')(core);
-    core.depHooks = mocks.depHooks();
-    core.patcher = patcher(core);
-
-    inputAnalysis = core.protect.inputAnalysis;
-
-    mockBusboy = function () { };
-    mockBusboy.prototype.emit = function () { };
-    sinon.spy(mockBusboy.prototype, 'emit');
-    sinon.spy(core.patcher, 'patch');
-
-    busboyInstr(core).install();
-    core.depHooks.resolve.yield(mockBusboy);
-    core.patcher.patch.resetHistory();
-  });
-
-  it('calls patcher on the `.emit` method', function () {
-    core.depHooks.resolve.yield(mockBusboy);
-
-    expect(core.patcher.patch).to.have.been.calledOnce;
-    expect(core.patcher.patch).to.have.been.calledWithMatch(mockBusboy.prototype, 'emit', {
-      name: 'busboy.prototype.emit',
-      patchType: 'protect-input-analysis',
-      pre: sinon.match.func
-    });
-  });
-
-  it('calls `.handleFileUploadName` when there is a multipart file and it is in right context', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      mockBusboy.prototype.emit('file', null, null, 'filename');
-    });
-
-    expect(inputAnalysis.handleFileUploadName).to.have.been.calledOnce;
-    expect(inputAnalysis.handleFileUploadName).to.have.been.calledWithMatch({}, ['filename']);
-  });
-
-
-  it('does not call `.handleFileUploadName` when not in context', function () {
-    core.scopes.sources.run({}, () => {
-      mockBusboy.prototype.emit('file', null, null, 'filename');
-    });
-
-    expect(inputAnalysis.handleFileUploadName).not.to.have.been.called;
-  });
-
-  it('does not call `.handleFileUploadName` when `.emit` is not called with `file` event', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      mockBusboy.prototype.emit('not-file', null, null, 'filename');
-    });
-
-    expect(inputAnalysis.handleParsedBody).not.to.have.been.called;
-    expect(core.logger.debug).not.to.have.been.called;
-  });
-
-  it('does not call `.handleFileUploadName` when `.emit` call does not contain a filename', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      mockBusboy.prototype.emit('not-file');
-    });
-
-    expect(inputAnalysis.handleParsedBody).not.to.have.been.called;
-    expect(core.logger.debug).not.to.have.been.called;
-  });
-});
-

package/lib/input-analysis/install/cookie-parser1.test.js

@@ -1,144 +0,0 @@
-'use strict';
-
-const sinon = require('sinon');
-const { expect } = require('chai');
-const scopes = require('@contrast/scopes');
-const patcher = require('@contrast/patcher');
-const mocks = require('@contrast/test/mocks');
-const SecurityException = require('../../security-exception');
-const secEx = SecurityException.create();
-const cookieParserInstr = require('./cookie-parser1');
-
-describe('protect input-analysis cookie-parser v1.x', function () {
-  let core, inputAnalysis, cookieParserMock, patchedCookieParser, cookie, signedCookie, nextStub;
-
-
-  beforeEach(function () {
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.scopes = scopes(core);
-    core.protect = mocks.protect();
-    require('../../get-source-context')(core);
-    core.depHooks = mocks.depHooks();
-    core.patcher = patcher(core);
-
-    inputAnalysis = core.protect.inputAnalysis;
-    cookie = {
-      cookie: { parameter: 'parsed' },
-    };
-    signedCookie = {
-      signedCookie: { secret: 'parsed' }
-    };
-    cookieParserMock = (cookies) => (req, res, next) => {
-      req.cookies = cookies?.cookie;
-      req.signedCookies = cookies?.signedCookie;
-      next();
-    };
-    nextStub = sinon.stub();
-    sinon.spy(core.patcher, 'patch');
-
-    cookieParserInstr(core).install();
-    patchedCookieParser = core.depHooks.resolve.yield(cookieParserMock)[0];
-    core.patcher.patch.resetHistory();
-  });
-
-  it('calls patcher on the `cookie-parser` module export', function () {
-    core.depHooks.resolve.yield(cookieParserMock);
-
-    expect(core.patcher.patch).to.have.been.calledOnce;
-    expect(core.patcher.patch).to.have.been.calledWithMatch(cookieParserMock, {
-      name: 'cookie-parser',
-      patchType: 'protect-input-analysis',
-      post: sinon.match.func
-    });
-  });
-
-  it('calls `.handleCookies` when parsing normal cookies is successful and in right context', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      const cParser = patchedCookieParser(cookie);
-      cParser({}, {}, nextStub);
-    });
-
-    expect(core.patcher.patch).to.have.been.calledOnce;
-    expect(core.patcher.patch).to.have.been.calledWithMatch(sinon.match.func, {
-      name: 'cookie-parser',
-      patchType: 'protect-input-analysis',
-      pre: sinon.match.func
-    });
-
-    expect(nextStub).to.have.been.calledOnce;
-    expect(inputAnalysis.handleCookies).to.have.been.calledOnce;
-    expect(inputAnalysis.handleCookies).to.have.been.calledWithMatch({ parsedCookies: { ...cookie.cookie } }, { ...cookie.cookie });
-  });
-
-  it('calls `.handleCookies` when parsing signed cookies is successful and in right context', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      const cParser = patchedCookieParser(signedCookie);
-      cParser({}, {}, nextStub);
-    });
-
-    expect(core.patcher.patch).to.have.been.calledOnce;
-    expect(core.patcher.patch).to.have.been.calledWithMatch(sinon.match.func, {
-      name: 'cookie-parser',
-      patchType: 'protect-input-analysis',
-      pre: sinon.match.func
-    });
-
-    expect(nextStub).to.have.been.calledOnce;
-    expect(inputAnalysis.handleCookies).to.have.been.calledOnce;
-    expect(inputAnalysis.handleCookies).to.have.been.calledWithMatch({ parsedCookies: { ...signedCookie.signedCookie } }, { ...signedCookie.signedCookie });
-  });
-
-  it('does not call `.handleCookies` when not in context', function () {
-    core.scopes.sources.run({}, () => {
-      const cParser = patchedCookieParser(cookie);
-      cParser({}, {}, nextStub);
-    });
-
-    expect(inputAnalysis.handleCookies).not.to.have.been.called;
-    expect(nextStub).to.have.been.calledOnce;
-  });
-
-  it('does not call `.handleCookies` when `cookie-parser` does not return a result', function () {
-    core.scopes.sources.run({ protect: {} }, () => {
-      const cParser = patchedCookieParser();
-      cParser({}, {}, nextStub);
-    });
-
-    core.scopes.sources.run({ protect: {} }, () => {
-      const cParser = patchedCookieParser({});
-      cParser({}, {}, nextStub);
-    });
-
-    expect(inputAnalysis.handleCookies).not.to.have.been.called;
-    expect(core.logger.debug).not.to.have.been.called;
-    expect(nextStub).to.have.been.calledTwice;
-  });
-
-  it('handles a case with SecurityException from `.handleCookies`', function () {
-    inputAnalysis.handleCookies.throws(secEx);
-    core.scopes.sources.run({ protect: {} }, () => {
-      const cParser = patchedCookieParser(cookie);
-      cParser({}, {}, nextStub);
-    });
-
-    expect(nextStub).to.have.been.calledOnceWith(secEx);
-  });
-
-  it('handles a case with an error in the input analysis from `.handleCookies`', function () {
-    const err = new Error('Input Analysis Error');
-
-    inputAnalysis.handleCookies.throws(err);
-    core.scopes.sources.run({ protect: {} }, () => {
-      const cParser = patchedCookieParser(cookie);
-      cParser({}, {}, nextStub);
-    });
-
-    expect(core.logger.error).to.have.been.calledWith(
-      { err, funcKey: 'protect-input-analysis:cookie-parser' },
-      'Unexpected error during input analysis'
-    );
-    expect(nextStub).to.have.been.calledOnce;
-    expect(nextStub).not.to.have.been.calledWith(err);
-  });
-});

package/lib/input-analysis/install/express.test.js

@@ -1,241 +0,0 @@
-'use strict';
-
-const sinon = require('sinon');
-const { expect } = require('chai');
-const scopes = require('@contrast/scopes');
-const patcher = require('@contrast/patcher');
-const mocks = require('@contrast/test/mocks');
-const SecurityException = require('../../security-exception');
-const secEx = SecurityException.create();
-const expressInstr = require('./express');
-
-describe('protect input-analysis express', function () {
-  let core,
-    inputAnalysis,
-    expressQueryMock,
-    requestMock,
-    nextStub,
-    query,
-    Layer;
-
-  beforeEach(function () {
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.scopes = scopes(core);
-    core.protect = mocks.protect();
-    require('../../get-source-context')(core);
-    core.depHooks = mocks.depHooks();
-    core.patcher = patcher(core);
-    sinon.spy(core.patcher, 'patch');
-
-    query = { parameter: 'parsed-query' };
-    expressQueryMock = (payload) => (req, res, next) => {
-      req.query = payload;
-      next();
-    };
-
-    requestMock = {
-      get query() {
-        return { parameter: 'parsed-query' };
-      }
-    };
-
-    Layer = sinon.stub();
-    Layer.prototype.match = sinon.stub().returns(true);
-
-    core.depHooks.resolve.withArgs({ name: 'express', version: '4', file: 'lib/middleware/query.js' }).yields(expressQueryMock);
-    core.depHooks.resolve.withArgs({ name: 'express', version: '5', file: 'lib/request.js' }).yields(requestMock);
-
-    nextStub = sinon.stub();
-
-    inputAnalysis = core.protect.inputAnalysis;
-    expressInstr(core).install();
-    expressQueryMock = core.patcher.patch.getCall(0).returnValue;
-    core.patcher.patch.resetHistory();
-  });
-
-  describe('express4 query patch', function () {
-    it('calls `.handleQueryParams` when parsing is successful and in right context', function () {
-      core.scopes.sources.run({ protect: {} }, () => {
-        const queryParser = expressQueryMock(query);
-        queryParser({}, {}, nextStub);
-      });
-
-      expect(core.patcher.patch).to.have.been.calledOnce;
-      expect(core.patcher.patch).to.have.been.calledWithMatch(sinon.match.func, {
-        name: 'express.query',
-        patchType: 'protect-input-analysis',
-        pre: sinon.match.func
-      });
-
-      expect(nextStub).to.have.been.calledOnce;
-      expect(inputAnalysis.handleQueryParams).to.have.been.calledOnce;
-      expect(inputAnalysis.handleQueryParams).to.have.been.calledWithMatch({ parsedQuery: query }, query);
-    });
-
-    it('does not call `.handleQueryParams` when not in context', function () {
-      core.scopes.sources.run({}, () => {
-        const queryParser = expressQueryMock(query);
-        queryParser({}, {}, nextStub);
-      });
-
-      expect(inputAnalysis.handleQueryParams).not.to.have.been.called;
-      expect(nextStub).to.have.been.calledOnce;
-    });
-
-    it('does not call `.handleQueryParams` when no query is passed to`express.query`', function () {
-      core.scopes.sources.run({ protect: {} }, () => {
-        const queryParser = expressQueryMock();
-        queryParser({}, {}, nextStub);
-      });
-
-      expect(inputAnalysis.handleQueryParams).not.to.have.been.called;
-      expect(nextStub).to.have.been.calledOnce;
-    });
-
-    it('does not call `.handleQueryParams` when query was already parsed', function () {
-      core.scopes.sources.run({ protect: { parsedQuery: query } }, () => {
-        const queryParser = expressQueryMock();
-        queryParser({}, {}, nextStub);
-      });
-
-      expect(inputAnalysis.handleQueryParams).not.to.have.been.called;
-      expect(nextStub).to.have.been.calledOnce;
-    });
-
-    it('handles a case with SecurityException from `.handleQueryParams`', function () {
-      inputAnalysis.handleQueryParams.throws(secEx);
-      core.scopes.sources.run({ protect: {} }, () => {
-        const queryParser = expressQueryMock(query);
-        queryParser({}, {}, nextStub);
-      });
-
-      expect(nextStub).to.have.been.calledOnceWith(secEx);
-    });
-
-    it('handles a case with an error in the input analysis from `.handleQueryParams`', function () {
-      const err = new Error('Input Analysis Error');
-
-      inputAnalysis.handleQueryParams.throws(err);
-      core.scopes.sources.run({ protect: {} }, () => {
-        const queryParser = expressQueryMock(query);
-        queryParser({}, {}, nextStub);
-      });
-
-      expect(core.logger.error).to.have.been.calledWith(
-        { err, funcKey: 'protect-input-analysis:express.query' },
-        'Unexpected error during input analysis'
-      );
-      expect(nextStub).to.have.been.calledOnce;
-      expect(nextStub).not.to.have.been.calledWith(err);
-    });
-  });
-
-  describe('express5 query get patch', function() {
-    it('does not call `.handleQueryParams` when not in context', function () {
-      core.scopes.sources.run({}, () => {
-        requestMock.query;
-      });
-
-      expect(inputAnalysis.handleQueryParams).not.to.have.been.called;
-    });
-
-    it('does not call `.handleQueryParams` when no query exists', function () {
-      requestMock = {
-        get query() {
-          return {};
-        }
-      };
-      core.scopes.sources.run({ protect: {} }, () => {
-        requestMock.query;
-      });
-
-      expect(inputAnalysis.handleQueryParams).not.to.have.been.called;
-    });
-
-    it('does not call `.handleQueryParams` when query was already parsed', function () {
-      core.scopes.sources.run({ protect: { parsedQuery: query } }, () => {
-        requestMock.query;
-      });
-
-      expect(inputAnalysis.handleQueryParams).not.to.have.been.called;
-    });
-
-    it('calls `.handleQueryParams` when parsing is successful and in right context', function () {
-      core.scopes.sources.run({ protect: {} }, () => {
-        requestMock.query;
-      });
-
-      expect(inputAnalysis.handleQueryParams).to.have.been.calledOnce;
-      expect(inputAnalysis.handleQueryParams).to.have.been.calledWithMatch({ parsedQuery: query }, query);
-    });
-  });
-
-  ['4', '5'].forEach((v) => {
-    describe(`express${v} Layer.prototype.match`, function() {
-      let layer;
-      beforeEach(function() {
-        const args = v === '4'
-          ? { name: 'express', version: '4', file: 'lib/router/layer.js' }
-          : { name: 'router', version: '2', file: 'lib/layer.js' };
-        core.depHooks.resolve.withArgs(args).yields(Layer);
-        expressInstr(core).install();
-        layer = { keys: ['foo'], params: { foo: 'bar' }, route: { path: '/test' } };
-      });
-
-      it('calls `.handleUrlParams` when parsing is successful and in right context', function () {
-        core.scopes.sources.run({ protect: {} }, () => {
-          Reflect.apply(Layer.prototype.match, layer, ['/bar']);
-        });
-
-        expect(inputAnalysis.handleUrlParams).to.have.been.calledOnce;
-        expect(inputAnalysis.handleUrlParams).to.have.been.calledWithMatch({ parsedParams: layer.params }, layer.params);
-      });
-
-      it('does not call `.handleUrlParams` when match returns false', function () {
-        Layer.prototype.match.returns(false);
-
-        core.scopes.sources.run({}, () => {
-          Reflect.apply(Layer.prototype.match, layer, ['/bar']);
-        });
-
-        expect(inputAnalysis.handleUrlParams).not.to.have.been.called;
-      });
-
-      it('does not call `.handleUrlParams` when the route path is undefined', function () {
-        core.scopes.sources.run({}, () => {
-          Reflect.apply(Layer.prototype.match, { ...layer, route: undefined }, ['/bar']);
-        });
-
-        expect(inputAnalysis.handleUrlParams).not.to.have.been.called;
-      });
-
-      it('does not call `.handleUrlParams` when the route path is `*`', function () {
-        core.scopes.sources.run({}, () => {
-          Reflect.apply(Layer.prototype.match, { ...layer, route: { path: '*' } }, ['/bar']);
-        });
-
-        expect(inputAnalysis.handleUrlParams).not.to.have.been.called;
-      });
-
-      it('does not call `.handleUrlParams` when not in context', function () {
-        core.scopes.sources.run({}, () => {
-          Reflect.apply(Layer.prototype.match, layer, ['/bar']);
-        });
-
-        expect(inputAnalysis.handleUrlParams).not.to.have.been.called;
-      });
-
-      it('does not call `.handleUrlParams` when no params are present on the current layer', function () {
-        layer = { keys: [], params: {} };
-
-        core.scopes.sources.run({ protect: {} }, () => {
-          Reflect.apply(Layer.prototype.match, layer, ['/bar']);
-        });
-
-        expect(inputAnalysis.handleUrlParams).not.to.have.been.called;
-      });
-
-    });
-  });
-});