kakapo/dist/interceptors/xhrInterceptor.js

Next generation mocking framework in Javascript

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var Response_1 = require("../Response");
var Request_1 = require("../Request");
var interceptorHelper_1 = require("./interceptorHelper");
var utils_1 = require("../utils");
var hasHandleEvent = function (listener) {
    return 'handleEvent' in listener;
};
var FakeXMLHttpRequest = (function () {
    function FakeXMLHttpRequest() {
        this._status = 0;
        this._readyState = FakeXMLHttpRequest.UNSENT;
        this._requestHeaders = {};
        this._responseHeaders = {};
        this._listeners = {
            abort: [],
            error: [],
            load: [],
            loadend: [],
            loadstart: [],
            progress: [],
            timeout: []
        };
        this.upload = new window.XMLHttpRequestEventTarget();
        this.interceptors = [];
    }
    FakeXMLHttpRequest.prototype.use = function (config) {
        this.interceptors.push(interceptorHelper_1.interceptorHelper(config));
    };
    FakeXMLHttpRequest.prototype.shouldIntercept = function (method, url) {
        return this.interceptors.some(function (interceptor) { return !!interceptor.getHandler(url, method); });
    };
    FakeXMLHttpRequest.prototype.open = function (method, url, async, user, password) {
        this._method = method;
        this._url = url;
        this._readyState = FakeXMLHttpRequest.OPENED;
    };
    Object.defineProperty(FakeXMLHttpRequest.prototype, "status", {
        get: function () {
            return this._status;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FakeXMLHttpRequest.prototype, "readyState", {
        get: function () {
            return this._readyState;
        },
        enumerable: true,
        configurable: true
    });
    FakeXMLHttpRequest.prototype._setReadyState = function (readyState) {
        this._readyState = readyState;
        if (this.onreadystatechange) {
            this.onreadystatechange(new Event('readystatechange'));
        }
    };
    Object.defineProperty(FakeXMLHttpRequest.prototype, "response", {
        get: function () {
            return this._response;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FakeXMLHttpRequest.prototype, "responseText", {
        get: function () {
            return this.response;
        },
        enumerable: true,
        configurable: true
    });
    FakeXMLHttpRequest.prototype.setRequestHeader = function (header, value) {
        this._requestHeaders[header] = value;
    };
    FakeXMLHttpRequest.prototype.getResponseHeader = function (header) {
        return this._responseHeaders[header];
    };
    FakeXMLHttpRequest.prototype.send = function (data) {
        var _this = this;
        var _a = this, method = _a._method, url = _a._url;
        var interceptors = this.interceptors.filter(function (interceptor) { return url && method && !!interceptor.getHandler(url, method); });
        if (interceptors.length > 0) {
            interceptors.forEach(function (interceptor) {
                if (url && method) {
                    var handler = interceptor.getHandler(url, method);
                    var db = interceptor.getDB();
                    if (handler && db) {
                        var delay_1 = interceptor.getDelay();
                        var request = new Request_1.KakapoRequest({
                            params: interceptor.getParams(url, method),
                            query: interceptor.getQuery(url),
                            body: data,
                            headers: _this._requestHeaders
                        });
                        var responsePromise = Promise.resolve(handler(request, db));
                        responsePromise.then(function (result) {
                            var response = Response_1.KakapoResponse.wrap(result);
                            if (delay_1) {
                                setTimeout(function () { return _this._handleResponse(response); }, delay_1);
                            }
                            else {
                                _this._handleResponse(response);
                            }
                        });
                    }
                }
            });
        }
        else {
            this.nativeSend(data);
        }
    };
    FakeXMLHttpRequest.prototype._handleResponse = function (_a) {
        var code = _a.code, headers = _a.headers, body = _a.body;
        var contentType = headers["content-type"];
        this._status = code;
        this._responseHeaders = headers;
        if (this.responseType === 'blob') {
            if (body instanceof Blob) {
                this._response = body;
            }
            else {
                this._response = new Blob([body]);
            }
        }
        else {
            this._response = JSON.stringify(body);
        }
        this._setReadyState(FakeXMLHttpRequest.DONE);
        var loadEvent = new ProgressEvent('load');
        if (this.onload) {
            this.onload(loadEvent);
        }
        this._listeners['load'].forEach(function (listener) {
            if (hasHandleEvent(listener)) {
                listener.handleEvent(loadEvent);
            }
            else {
                listener(loadEvent);
            }
        });
    };
    FakeXMLHttpRequest.prototype.addEventListener = function (type, listener) {
        this._listeners[type].push(listener);
    };
    FakeXMLHttpRequest.prototype.removeEventListener = function (type, listener) {
        var index = this._listeners[type].indexOf(listener);
        if (index >= 0) {
            this._listeners[type].splice(index, 1);
        }
    };
    FakeXMLHttpRequest.prototype.nativeSend = function (data) {
        var _this = this;
        var request = new NativeXMLHttpRequest();
        if (this.timeout) {
            request.timeout = this.timeout;
        }
        request.onload = function () {
            var headers = request
                .getAllResponseHeaders()
                .split('\r\n')
                .reduce(function (previous, current) {
                var _a;
                var _b = current.split(': '), header = _b[0], value = _b[1];
                return __assign({}, previous, (_a = {}, _a[header] = value, _a));
            }, {});
            var response = new Response_1.KakapoResponse(request.status, request.response, headers);
            _this._handleResponse(response);
        };
        if (this._method && this._url) {
            request.open(this._method, this._url);
            request.send(data);
        }
    };
    FakeXMLHttpRequest.UNSENT = 0;
    FakeXMLHttpRequest.OPENED = 1;
    FakeXMLHttpRequest.HEADERS_RECEIVED = 2;
    FakeXMLHttpRequest.LOADING = 3;
    FakeXMLHttpRequest.DONE = 4;
    return FakeXMLHttpRequest;
}());
var FakeXMLHttpRequestEventTarget = (function () {
    function FakeXMLHttpRequestEventTarget() {
    }
    FakeXMLHttpRequestEventTarget.prototype.addEventListener = function (type, listener, useCaptureOrOptions) {
        if (useCaptureOrOptions === void 0) { useCaptureOrOptions = false; }
    };
    return FakeXMLHttpRequestEventTarget;
}());
var NativeXMLHttpRequest;
var NativeXMLHttpRequestEventTarget;
exports.enable = function (config) {
    if (!utils_1.canUseWindow) {
        throw new Error("You're trying to use XHR interceptor in non-browser environment");
    }
    if (!NativeXMLHttpRequest || !NativeXMLHttpRequestEventTarget) {
        NativeXMLHttpRequest = XMLHttpRequest;
        NativeXMLHttpRequestEventTarget = XMLHttpRequestEventTarget;
    }
    window.XMLHttpRequest = function () {
        var fakeXMLHttpRequest = new FakeXMLHttpRequest();
        fakeXMLHttpRequest.use(config);
        return fakeXMLHttpRequest;
    };
    window.XMLHttpRequestEventTarget = FakeXMLHttpRequestEventTarget;
};
exports.disable = function () {
    window.XMLHttpRequest = NativeXMLHttpRequest;
    window.XMLHttpRequestEventTarget = NativeXMLHttpRequestEventTarget;
};