@4c/fetch-mock/es5/lib/fetch-handler.js

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

"use strict";

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

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

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

var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs3/regenerator"));

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

var responseBuilder = require('./response-builder');

var requestUtils = require('./request-utils');

var FetchMock = {};

var resolve =
/*#__PURE__*/
function () {
  var _ref = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee(response, url, options, request) {
    return _regenerator["default"].wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(typeof response === 'function' || typeof response.then === 'function')) {
              _context.next = 10;
              break;
            }

            if (!(typeof response === 'function')) {
              _context.next = 5;
              break;
            }

            response = response(url, options, request);
            _context.next = 8;
            break;

          case 5:
            _context.next = 7;
            return response;

          case 7:
            response = _context.sent;

          case 8:
            _context.next = 0;
            break;

          case 10:
            return _context.abrupt("return", response);

          case 11:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function resolve(_x, _x2, _x3, _x4) {
    return _ref.apply(this, arguments);
  };
}();

FetchMock.fetchHandler = function (url, options, request) {
  var _this = this;

  var _requestUtils$normali = requestUtils.normalizeRequest(url, options, this.config.Request);

  url = _requestUtils$normali.url;
  options = _requestUtils$normali.options;
  request = _requestUtils$normali.request;
  var route = this.executeRouter(url, options, request); // this is used to power the .flush() method

  var done;

  this._holdingPromises.push(new this.config.Promise(function (res) {
    return done = res;
  })); // wrapped in this promise to make sure we respect custom Promise
  // constructors defined by the user


  return new this.config.Promise(function (res, rej) {
    if (options && options.signal) {
      var abort = function abort() {
        rej(new Error("URL '".concat(url, "' aborted.")));
        done();
      };

      if (options.signal.aborted) {
        abort();
      }

      options.signal.addEventListener('abort', abort);
    }

    _this.generateResponse(route, url, options, request).then(res, rej).then(done, done);
  });
};

FetchMock.fetchHandler.isMock = true;

FetchMock.executeRouter = function (url, options, request) {
  if (this.config.fallbackToNetwork === 'always') {
    return {
      response: this.getNativeFetch()
    };
  }

  var match = this.router(url, options, request);

  if (match) {
    return match;
  }

  if (this.config.warnOnFallback) {
    var _context2;

    console.warn((0, _concat["default"])(_context2 = "Unmatched ".concat(options && options.method || 'GET', " to ")).call(_context2, url)); // eslint-disable-line
  }

  this.push({
    url: url,
    options: options,
    request: request,
    isUnmatched: true
  });

  if (this.fallbackResponse) {
    return {
      response: this.fallbackResponse
    };
  }

  if (!this.config.fallbackToNetwork) {
    var _context3;

    throw new Error((0, _concat["default"])(_context3 = "fetch-mock: No fallback response defined for ".concat(options && options.method || 'GET', " to ")).call(_context3, url));
  }

  return {
    response: this.getNativeFetch()
  };
};

FetchMock.generateResponse =
/*#__PURE__*/
function () {
  var _ref2 = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee2(route, url, options, request) {
    var response;
    return _regenerator["default"].wrap(function _callee2$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _context4.next = 2;
            return resolve(route.response, url, options, request);

          case 2:
            response = _context4.sent;

            if (!(response["throws"] && typeof response !== 'function')) {
              _context4.next = 5;
              break;
            }

            throw response["throws"];

          case 5:
            if (!this.config.Response.prototype.isPrototypeOf(response)) {
              _context4.next = 7;
              break;
            }

            return _context4.abrupt("return", response);

          case 7:
            return _context4.abrupt("return", responseBuilder({
              url: url,
              responseConfig: response,
              fetchMock: this,
              route: route
            }));

          case 8:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee2, this);
  }));

  return function (_x5, _x6, _x7, _x8) {
    return _ref2.apply(this, arguments);
  };
}();

FetchMock.router = function (url, options, request) {
  var _context5;

  var route = (0, _find["default"])(_context5 = this.routes).call(_context5, function (route) {
    return route.matcher(url, options, request);
  });

  if (route) {
    this.push({
      url: url,
      options: options,
      request: request,
      identifier: route.identifier
    });
    return route;
  }
};

FetchMock.getNativeFetch = function () {
  var func = this.realFetch || this.isSandbox && this.config.fetch;

  if (!func) {
    throw new Error('fetch-mock: Falling back to network only available on gloabl fetch-mock, or by setting config.fetch on sandboxed fetch-mock');
  }

  return func;
};

FetchMock.push = function (_ref3) {
  var url = _ref3.url,
      options = _ref3.options,
      request = _ref3.request,
      isUnmatched = _ref3.isUnmatched,
      identifier = _ref3.identifier;
  var args = [url, options];
  args.request = request;
  args.identifier = identifier;
  args.isUnmatched = isUnmatched;

  this._calls.push(args);
};

module.exports = FetchMock;