@appzmonster/fetch-interceptor/MockRequest.js

Fetch-interceptor is a JavaScript library to enable request interceptor feature on Fetch API. The library extends Fetch API and uses fluent API design to allow chaining of one or multiple request interceptors to a Fetch API request.

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _BaseInterceptor2 = _interopRequireDefault(require("./BaseInterceptor"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }

function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

var MockRequest = /*#__PURE__*/function (_BaseInterceptor) {
  _inherits(MockRequest, _BaseInterceptor);

  var _super = _createSuper(MockRequest);

  function MockRequest(mock) {
    var _this;

    _classCallCheck(this, MockRequest);

    _this = _super.call(this);
    _this._mock = Object.assign({}, {
      data: null,
      dataType: 'application/json',
      delay: 1000,
      // Delay for 1 second by default.
      ok: true,
      // For Response.ok - true or false.
      status: 200,
      statusText: 'OK',
      simulateNetworkError: false,
      // To simulate request fail to complete, thus throwing error.
      disabled: false // Disable to enable this mock interceptor.

    }, mock);
    return _this;
  }

  _createClass(MockRequest, [{
    key: "invoke",
    value: function () {
      var _invoke = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(resource, init) {
        var _this2 = this;

        var promise;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (!(this._mock.disabled === true)) {
                  _context.next = 4;
                  break;
                }

                _context.next = 3;
                return _get(_getPrototypeOf(MockRequest.prototype), "fetch", this).call(this, resource, init);

              case 3:
                return _context.abrupt("return", _context.sent);

              case 4:
                promise = new Promise(function (resolve, reject) {
                  setTimeout(function () {
                    var mockBlob = null;

                    if (_this2._mock.dataType.toLowerCase() === 'application/json') {
                      mockBlob = new Blob([JSON.stringify(_this2._mock.data)], {
                        type: _this2._mock.dataType
                      });
                    } else {
                      mockBlob = new Blob([_this2._mock.data], {
                        type: _this2._mock.dataType
                      });
                    }

                    var mockResponse = new Response(mockBlob, {
                      status: _this2._mock.status,
                      statusText: _this2._mock.statusText
                    });
                    /*
                        Reference: MDN
                        The Promise returned from fetch() won’t reject on HTTP error status even 
                        if the response is an HTTP 404 or 500. Instead, as soon as the server responds 
                        with headers, the Promise will resolve normally (with the ok property of the 
                        response set to false if the response isn’t in the range 200–299), and it will 
                        only reject on network failure or if anything prevented the request from completing.
                    */

                    if (_this2._mock.simulateNetworkError === true) {
                      var networkError = new TypeError('Network request failed');
                      reject(networkError);
                    } else {
                      // Resolve response even if it's an error because the request completed.
                      resolve(mockResponse);
                    }
                  }, _this2._mock.delay);
                });
                return _context.abrupt("return", promise);

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

      function invoke(_x, _x2) {
        return _invoke.apply(this, arguments);
      }

      return invoke;
    }()
  }]);

  return MockRequest;
}(_BaseInterceptor2["default"]);

var _default = MockRequest;
exports["default"] = _default;