axios-mockadptr 0.0.1-security → 2.1.0

package/src/handle_request.js

@@ -0,0 +1,88 @@
+"use strict";
+const utils = require("./utils");
+
+function passThroughRequest (mockAdapter, config) {
+  // Axios v0.17 mutates the url to include the baseURL for non hostnames
+  // but does not remove the baseURL from the config
+  let baseURL = config.baseURL;
+  if (baseURL && !/^https?:/.test(baseURL)) {
+    baseURL = undefined;
+  }
+
+  // Axios pre 1.2
+  if (typeof mockAdapter.originalAdapter === "function") {
+    return mockAdapter.originalAdapter(config);
+  }
+
+  return mockAdapter.axiosInstanceWithoutInterceptors(Object.assign({}, config, {
+    baseURL,
+    //  Use the original adapter, not the mock adapter
+    adapter: mockAdapter.originalAdapter,
+    // The request transformation runs on the original axios handler already
+    transformRequest: [],
+    transformResponse: []
+  }));
+}
+
+async function handleRequest(mockAdapter, config) {
+  let url = config.url || "";
+  // TODO we're not hitting this `if` in any of the tests, investigate
+  if (
+    config.baseURL &&
+    url.substr(0, config.baseURL.length) === config.baseURL
+  ) {
+    url = url.slice(config.baseURL.length);
+  }
+
+  delete config.adapter;
+  mockAdapter.history.push(config);
+
+  const handler = utils.findHandler(
+    mockAdapter.handlers,
+    config.method,
+    url,
+    config.data,
+    config.params,
+    (config.headers && config.headers.constructor.name === "AxiosHeaders")
+      ? Object.assign({}, config.headers.toJSON())
+      : config.headers,
+    config.baseURL
+  );
+
+  if (handler) {
+    if (handler.replyOnce) {
+      utils.purgeIfReplyOnce(mockAdapter, handler);
+    }
+
+    if (handler.passThrough) {
+      // passThrough handler
+      return passThroughRequest(mockAdapter, config);
+    } else {
+      return utils.settle(
+        config,
+        handler.response,
+        getEffectiveDelay(mockAdapter, handler)
+      );
+    }
+  } else {
+    // handler not found
+    switch (mockAdapter.onNoMatch) {
+      case "passthrough":
+        return passThroughRequest(mockAdapter, config);
+      case "throwException":
+        throw utils.createCouldNotFindMockError(config);
+      default:
+        return utils.settle(
+          config,
+          { status: 404 },
+          mockAdapter.delayResponse
+        );
+    }
+  }
+}
+
+function getEffectiveDelay(adapter, handler) {
+  return typeof handler.delay === "number" ? handler.delay : adapter.delayResponse;
+}
+
+module.exports = handleRequest;

package/src/index.js

@@ -0,0 +1,285 @@
+"use strict";
+const handleRequest = require("./handle_request");
+const utils = require("./utils");
+
+const VERBS = [
+  "get",
+  "post",
+  "head",
+  "delete",
+  "patch",
+  "put",
+  "options",
+  "list",
+  "link",
+  "unlink",
+];
+
+function getVerbArray() {
+  const arr = [];
+  VERBS.forEach(function (verb) {
+    Object.defineProperty(arr, verb, {
+      get () {
+        return arr.filter(function (h) {
+          return !h.method || h.method === verb;
+        });
+      },
+    });
+  });
+  return arr;
+}
+
+class AxiosMockAdapter {
+  constructor (axiosInstance, options = {}) {
+    this.reset();
+
+    if (axiosInstance) {
+      this.axiosInstance = axiosInstance;
+      // Clone the axios instance to remove interceptors
+      // this is used for the passThrough mode with axios > 1.2
+      this.axiosInstanceWithoutInterceptors = axiosInstance.create
+        ? axiosInstance.create()
+        : undefined;
+
+      this.originalAdapter = axiosInstance.defaults.adapter;
+      this.delayResponse = options.delayResponse > 0 ? options.delayResponse : null;
+      this.onNoMatch = options.onNoMatch || null;
+      axiosInstance.defaults.adapter = this.adapter();
+    } else {
+      throw new Error("Please provide an instance of axios to mock");
+    }
+  }
+
+  adapter () {
+    return (config) => handleRequest(this, config);
+  }
+
+  restore () {
+    if (!this.axiosInstance) return;
+    this.axiosInstance.defaults.adapter = this.originalAdapter;
+    this.axiosInstance = undefined;
+  }
+
+  reset () {
+    this.resetHandlers();
+    this.resetHistory();
+  }
+
+  resetHandlers () {
+    if (this.handlers) this.handlers.length = 0;
+    else this.handlers = getVerbArray();
+  }
+
+  resetHistory () {
+    if (this.history) this.history.length = 0;
+    else this.history = getVerbArray();
+  }
+}
+
+const methodsWithConfigsAsSecondArg = ["any", "get", "delete", "head", "options"];
+function convertDataAndConfigToConfig (method, data, config) {
+  if (methodsWithConfigsAsSecondArg.includes(method)) {
+    return validateconfig(method, data || {});
+  } else {
+    return validateconfig(method, Object.assign({}, config, { data: data }));
+  }
+}
+
+const allowedConfigProperties = ["headers", "params", "data"];
+function validateconfig (method, config) {
+  for (const key in config) {
+    if (!allowedConfigProperties.includes(key)) {
+      throw new Error(
+        `Invalid config property ${
+        JSON.stringify(key)
+        } provided to ${
+        toMethodName(method)
+        }. Config: ${
+        JSON.stringify(config)}`
+      );
+    }
+  }
+
+  return config;
+}
+
+function toMethodName (method) {
+  return `on${method.charAt(0).toUpperCase()}${method.slice(1)}`;
+}
+
+VERBS.concat("any").forEach(function (method) {
+  AxiosMockAdapter.prototype[toMethodName(method)] = function (matcher, data, config) {
+    const self = this;
+    let delay;
+    matcher = matcher === undefined ? /.*/ : matcher;
+
+    const paramsAndBody = convertDataAndConfigToConfig(method, data, config);
+
+    function reply (code, response, headers) {
+      const handler = {
+        url: matcher,
+        method: method === "any" ? undefined : method,
+        params: paramsAndBody.params,
+        data: paramsAndBody.data,
+        headers: paramsAndBody.headers,
+        replyOnce: false,
+        delay,
+        response: typeof code === "function" ? code : [
+          code,
+          response,
+          headers
+        ]
+      };
+      addHandler(method, self.handlers, handler);
+      return self;
+    }
+
+    function withDelayInMs (_delay) {
+      delay = _delay;
+      const respond = requestApi.reply.bind(requestApi);
+      Object.assign(respond, requestApi);
+      return respond;
+    }
+
+    function replyOnce (code, response, headers) {
+      const handler = {
+        url: matcher,
+        method: method === "any" ? undefined : method,
+        params: paramsAndBody.params,
+        data: paramsAndBody.data,
+        headers: paramsAndBody.headers,
+        replyOnce: true,
+        delay: delay,
+        response: typeof code === "function" ? code : [
+          code,
+          response,
+          headers
+        ]
+      };
+      addHandler(method, self.handlers, handler);
+      return self;
+    }
+
+    const requestApi = {
+      reply,
+      replyOnce,
+      withDelayInMs,
+      passThrough () {
+        const handler = {
+          passThrough: true,
+          method: method === "any" ? undefined : method,
+          url: matcher,
+          params: paramsAndBody.params,
+          data: paramsAndBody.data,
+          headers: paramsAndBody.headers
+        };
+        addHandler(method, self.handlers, handler);
+        return self;
+      },
+      abortRequest () {
+        return reply(async function (config) {
+          throw utils.createAxiosError(
+            "Request aborted",
+            config,
+            undefined,
+            "ECONNABORTED"
+          );
+        });
+      },
+      abortRequestOnce () {
+        return replyOnce(async function (config) {
+          throw utils.createAxiosError(
+            "Request aborted",
+            config,
+            undefined,
+            "ECONNABORTED"
+          );
+        });
+      },
+
+      networkError () {
+        return reply(async function (config) {
+          throw utils.createAxiosError("Network Error", config);
+        });
+      },
+
+      networkErrorOnce () {
+        return replyOnce(async function (config) {
+          throw utils.createAxiosError("Network Error", config);
+        });
+      },
+
+      timeout () {
+        return reply(async function (config) {
+          throw utils.createAxiosError(
+            config.timeoutErrorMessage ||
+              `timeout of ${config.timeout  }ms exceeded`,
+            config,
+            undefined,
+            config.transitional && config.transitional.clarifyTimeoutError
+              ? "ETIMEDOUT"
+              : "ECONNABORTED"
+          );
+        });
+      },
+
+      timeoutOnce () {
+        return replyOnce(async function (config) {
+          throw utils.createAxiosError(
+            config.timeoutErrorMessage ||
+              `timeout of ${config.timeout  }ms exceeded`,
+            config,
+            undefined,
+            config.transitional && config.transitional.clarifyTimeoutError
+              ? "ETIMEDOUT"
+              : "ECONNABORTED"
+          );
+        });
+      },
+    };
+
+    return requestApi;
+  };
+});
+
+function findInHandlers (handlers, handler) {
+  let index = -1;
+  for (let i = 0; i < handlers.length; i += 1) {
+    const item = handlers[i];
+    const comparePaths =
+      item.url instanceof RegExp && handler.url instanceof RegExp
+        ? String(item.url) === String(handler.url)
+        : item.url === handler.url;
+
+    const isSame =
+      (!item.method || item.method === handler.method) &&
+      comparePaths &&
+      utils.isEqual(item.params, handler.params) &&
+      utils.isEqual(item.data, handler.data) &&
+      utils.isEqual(item.headers, handler.headers);
+
+    if (isSame && !item.replyOnce) {
+      index = i;
+    }
+  }
+  return index;
+}
+
+function addHandler (method, handlers, handler) {
+  if (method === "any") {
+    handlers.push(handler);
+  } else {
+    const indexOfExistingHandler = findInHandlers(handlers, handler);
+    // handler.replyOnce indicates that a handler only runs once.
+    // It's supported to register muliple ones like that without
+    // overwriting the previous one.
+    if (indexOfExistingHandler > -1 && !handler.replyOnce) {
+      handlers.splice(indexOfExistingHandler, 1, handler);
+    } else {
+      handlers.push(handler);
+    }
+  }
+}
+
+module.exports = AxiosMockAdapter;
+module.exports.default = AxiosMockAdapter;

package/src/is_blob.js

@@ -0,0 +1,28 @@
+/*!
+ * MIT License
+ *
+ * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+function isBlob(value) {
+  if (typeof Blob === "undefined") {
+    return false;
+  }
+
+  return value instanceof Blob || Object.prototype.toString.call(value) === "[object Blob]";
+}
+
+module.exports = isBlob;

package/src/utils.js

@@ -0,0 +1,224 @@
+"use strict";
+const axios = require("axios");
+const isEqual = require("fast-deep-equal");
+const isBuffer = require("is-buffer");
+const isBlob = require("./is_blob");
+const toString = Object.prototype.toString;
+
+function find(array, predicate) {
+  const length = array.length;
+  for (let i = 0; i < length; i++) {
+    const value = array[i];
+    if (predicate(value)) return value;
+  }
+}
+
+function isFunction(val) {
+  return toString.call(val) === "[object Function]";
+}
+
+function isObjectOrArray(val) {
+  return val !== null && typeof val === "object";
+}
+
+function isStream(val) {
+  return isObjectOrArray(val) && isFunction(val.pipe);
+}
+
+function isArrayBuffer(val) {
+  return toString.call(val) === "[object ArrayBuffer]";
+}
+
+function combineUrls(baseURL, url) {
+  if (baseURL) {
+    return `${baseURL.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}`;
+  }
+
+  return url;
+}
+
+function findHandler(
+  handlers,
+  method,
+  url,
+  body,
+  parameters,
+  headers,
+  baseURL
+) {
+  return find(handlers[method.toLowerCase()], function (handler) {
+    let matchesUrl = false;
+    if (typeof handler.url === "string") {
+      matchesUrl  = isUrlMatching(url, handler.url) ||
+        isUrlMatching(combineUrls(baseURL, url), handler.url);
+    } else if (handler.url instanceof RegExp) {
+      matchesUrl = handler.url.test(url) ||
+        handler.url.test(combineUrls(baseURL, url));
+    }
+
+    return matchesUrl &&
+      isBodyOrParametersMatching(body, parameters, handler) &&
+      isObjectMatching(headers, handler.headers);
+  });
+}
+
+function isUrlMatching(url, required) {
+  const noSlashUrl = url[0] === "/" ? url.substr(1) : url;
+  const noSlashRequired = required[0] === "/" ? required.substr(1) : required;
+  return noSlashUrl === noSlashRequired;
+}
+
+function isBodyOrParametersMatching(body, parameters, required) {
+  return isObjectMatching(parameters, required.params) &&
+    isBodyMatching(body, required.data);
+}
+
+function isObjectMatching(actual, expected) {
+  if (expected === undefined) return true;
+  if (typeof expected.asymmetricMatch === "function") {
+    return expected.asymmetricMatch(actual);
+  }
+  return isEqual(actual, expected);
+}
+
+function isBodyMatching(body, requiredBody) {
+  if (requiredBody === undefined) {
+    return true;
+  }
+  let parsedBody;
+  try {
+    parsedBody = JSON.parse(body);
+  } catch (_e) {}
+
+  return isObjectMatching(parsedBody ? parsedBody : body, requiredBody);
+}
+
+function purgeIfReplyOnce(mock, handler) {
+  const index = mock.handlers.indexOf(handler);
+  if (index > -1) {
+    mock.handlers.splice(index, 1);
+  }
+}
+
+function transformRequest(data) {
+  if (
+    isArrayBuffer(data) ||
+    isBuffer(data) ||
+    isStream(data) ||
+    isBlob(data)
+  ) {
+    return data;
+  }
+
+  // Object and Array: returns a deep copy
+  if (isObjectOrArray(data)) {
+    return JSON.parse(JSON.stringify(data));
+  }
+
+  // for primitives like string, undefined, null, number
+  return data;
+}
+
+async function makeResponse(result, config) {
+  if (typeof result === "function") result = await result(config);
+
+  const status = result.status || result[0];
+  const data = transformRequest(result.data || result[1]);
+  const headers = result.headers || result[2];
+  if (result.config) config = result.config;
+
+  return {
+    status,
+    data,
+    headers,
+    config,
+    request: { responseURL: config.url }
+  };
+}
+
+async function settle(config, response, delay) {
+  if (delay > 0) await new Promise(resolve => setTimeout(resolve, delay));
+
+  const result = await makeResponse(response, config);
+
+  if (
+    !result.config.validateStatus ||
+    result.config.validateStatus(result.status)
+  ) {
+    return result;
+  } else {
+    throw createAxiosError(
+      `Request failed with status code ${result.status}`,
+      result.config,
+      result
+    );
+  }
+}
+
+function createAxiosError(message, config, response, code) {
+  // axios v0.27.0+ defines AxiosError as constructor
+  if (typeof axios.AxiosError === "function") {
+    return axios.AxiosError.from(new Error(message), code, config, null, response);
+  }
+
+  // handling for axios v0.26.1 and below
+  const error = new Error(message);
+  error.isAxiosError = true;
+  error.config = config;
+  if (response !== undefined) {
+    error.response = response;
+  }
+  if (code !== undefined) {
+    error.code = code;
+  }
+
+  error.toJSON = function toJSON() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: this.config,
+      code: this.code,
+    };
+  };
+  return error;
+}
+
+function createCouldNotFindMockError(config) {
+  const message =
+    `Could not find mock for: \n${
+    JSON.stringify({
+      method: config.method,
+      url: config.url,
+      params: config.params,
+      headers: config.headers
+    }, null, 2)}`;
+  const error = new Error(message);
+  error.isCouldNotFindMockError = true;
+  error.url = config.url;
+  error.method = config.method;
+  return error;
+}
+
+module.exports = {
+  find,
+  findHandler,
+  purgeIfReplyOnce,
+  settle,
+  isObjectOrArray,
+  isBuffer,
+  isBlob,
+  isBodyOrParametersMatching,
+  isEqual,
+  createAxiosError,
+  createCouldNotFindMockError,
+};