@4c/fetch-mock/es5/lib/generate-matcher.js

Mock http requests made using fetch (or isomorphic-fetch)

"use strict";

var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");

var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));

var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));

var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));

var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));

var _every = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/every"));

var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));

var _glob = require('glob-to-regexp');

var pathToRegexp = require('path-to-regexp');

var querystring = require('querystring');

var _require = require('./request-utils'),
    headerUtils = _require.headers,
    getPath = _require.getPath,
    getQuery = _require.getQuery,
    normalizeUrl = _require.normalizeUrl;

var stringMatchers = {
  begin: function begin(targetString) {
    return function (url) {
      return (0, _indexOf["default"])(url).call(url, targetString) === 0;
    };
  },
  end: function end(targetString) {
    return function (url) {
      return url.substr(-targetString.length) === targetString;
    };
  },
  glob: function glob(targetString) {
    var urlRX = _glob(targetString);

    return function (url) {
      return urlRX.test(url);
    };
  },
  express: function express(targetString) {
    var urlRX = pathToRegexp(targetString);
    return function (url) {
      return urlRX.test(getPath(url));
    };
  },
  path: function path(targetString) {
    return function (url) {
      return getPath(url) === targetString;
    };
  }
};

var getHeaderMatcher = function getHeaderMatcher(_ref) {
  var expectedHeaders = _ref.headers;
  var expectation = headerUtils.toLowerCase(expectedHeaders);
  return function (url, _ref2) {
    var _context;

    var _ref2$headers = _ref2.headers,
        headers = _ref2$headers === void 0 ? {} : _ref2$headers;
    var lowerCaseHeaders = headerUtils.toLowerCase(headerUtils.normalize(headers));
    return (0, _every["default"])(_context = (0, _keys["default"])(expectation)).call(_context, function (headerName) {
      return headerUtils.equal(lowerCaseHeaders[headerName], expectation[headerName]);
    });
  };
};

var getMethodMatcher = function getMethodMatcher(_ref3) {
  var expectedMethod = _ref3.method;
  return function (url, _ref4) {
    var method = _ref4.method;
    return expectedMethod === (method ? method.toLowerCase() : 'get');
  };
};

var getQueryStringMatcher = function getQueryStringMatcher(_ref5) {
  var expectedQuery = _ref5.query;
  var keys = (0, _keys["default"])(expectedQuery);
  return function (url) {
    var query = querystring.parse(getQuery(url));
    return (0, _every["default"])(keys).call(keys, function (key) {
      return query[key] === expectedQuery[key];
    });
  };
};

var getParamsMatcher = function getParamsMatcher(_ref6) {
  var expectedParams = _ref6.params,
      matcher = _ref6.matcher;

  if (!/express:/.test(matcher)) {
    throw new Error('fetch-mock: matching on params is only possible when using an express: matcher');
  }

  var expectedKeys = (0, _keys["default"])(expectedParams);
  var keys = [];
  var re = pathToRegexp(matcher.replace(/^express:/, ''), keys);
  return function (url) {
    var vals = re.exec(getPath(url)) || [];
    vals.shift();
    var params = (0, _reduce["default"])(keys).call(keys, function (map, _ref7, i) {
      var name = _ref7.name;
      return vals[i] ? (0, _assign["default"])(map, (0, _defineProperty2["default"])({}, name, vals[i])) : map;
    }, {});
    return (0, _every["default"])(expectedKeys).call(expectedKeys, function (key) {
      return params[key] === expectedParams[key];
    });
  };
};

var getFunctionMatcher = function getFunctionMatcher(_ref8) {
  var matcher = _ref8.matcher,
      _ref8$functionMatcher = _ref8.functionMatcher,
      functionMatcher = _ref8$functionMatcher === void 0 ? function () {
    return true;
  } : _ref8$functionMatcher;
  return typeof matcher === 'function' ? matcher : functionMatcher;
};

var getUrlMatcher = function getUrlMatcher(route) {
  var matcher = route.matcher,
      query = route.query;

  if (typeof matcher === 'function') {
    return function () {
      return true;
    };
  }

  if (matcher instanceof RegExp) {
    return function (url) {
      return matcher.test(url);
    };
  }

  if (matcher === '*') {
    return function () {
      return true;
    };
  }

  for (var shorthand in stringMatchers) {
    if ((0, _indexOf["default"])(matcher).call(matcher, shorthand + ':') === 0) {
      var url = matcher.replace(new RegExp("^".concat(shorthand, ":")), '');
      return stringMatchers[shorthand](url);
    }
  } // if none of the special syntaxes apply, it's just a simple string match
  // but we have to be careful to normalize the url we check and the name
  // of the route to allow for e.g. http://it.at.there being indistinguishable
  // from http://it.at.there/ once we start generating Request/Url objects


  var expectedUrl = normalizeUrl(matcher);

  if (route.identifier === matcher) {
    route.identifier = expectedUrl;
  }

  return function (url) {
    if (query && (0, _indexOf["default"])(expectedUrl).call(expectedUrl, '?')) {
      return (0, _indexOf["default"])(url).call(url, expectedUrl) === 0;
    }

    return normalizeUrl(url) === expectedUrl;
  };
};

module.exports = function (route) {
  var _context2;

  var matchers = (0, _filter["default"])(_context2 = [route.query && getQueryStringMatcher(route), route.method && getMethodMatcher(route), route.headers && getHeaderMatcher(route), route.params && getParamsMatcher(route), getFunctionMatcher(route), getUrlMatcher(route)]).call(_context2, function (matcher) {
    return !!matcher;
  });
  return function (url) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var request = arguments.length > 2 ? arguments[2] : undefined;
    return (0, _every["default"])(matchers).call(matchers, function (matcher) {
      return matcher(url, options, request);
    });
  };
};