mm.js

'use strict';

const EventEmitter = require('events');
const is = require('is-type-of');
const muk = require('muk-prop');
const http = require('http');
const https = require('https');
const cp = require('child_process');
const thenify = require('thenify').withCallback;
const Readable = require('stream').Readable;
const Duplex = require('stream').Duplex;

const mock = module.exports = function mock(target, property, value) {
  value = spyFunction(target, property, value);
  return muk(target, property, value);
};

function spyFunction(target, property, fn) {
  if (!is.function(fn)) return fn;
  // support mock with jest.fn()
  if (fn._isMockFunction && fn.mock) return fn;

  // don't allow mock async function to common function
  const isGenerator = is.generatorFunction(fn);
  const isAsyncLike = !isGenerator && isAsyncLikeFunction(target, property);
  return new Proxy(fn, {
    apply(target, thisArg, args) {
      fn.called = fn.called || 0;
      fn.calledArguments = fn.calledArguments || [];
      fn.calledArguments.push(args);
      fn.lastCalledArguments = args;
      fn.called++;
      const res = Reflect.apply(target, thisArg, args);
      if (isAsyncLike && !is.promise(res)) {
        throw new Error(`Can\'t mock async function to normal function for property "${property}"`);
      }
      return res;
    },
  });
}

function isAsyncLikeFunction(target, property) {
  // don't call getter
  // Object.getOwnPropertyDescriptor can't find getter in prototypes
  if (target.__lookupGetter__(property)) return false;
  return is.asyncFunction(target[property]) || is.generatorFunction(target[property]);
}

exports = mock;

function getCallback(args) {
  let index = args.length - 1;
  let callback = args[index];
  while (typeof callback !== 'function') {
    index--;
    if (index < 0) {
      break;
    }
    callback = args[index];
  }

  if (!callback) {
    throw new TypeError('Can\'t find callback function');
  }

  // support thunk fn(a1, a2, cb, cbThunk)
  if (typeof args[index - 1] === 'function') {
    callback = args[index - 1];
  }
  return callback;
}

exports.isMocked = muk.isMocked;

/**
 * create an error instance
 *
 * @param  {String|Error} error - error
 * @param  {Object} props - props
 * @return {Error} error - error
 */
exports._createError = function(error, props) {
  if (!error) {
    error = new Error('mm mock error');
    error.name = 'MockError';
  }
  if (typeof error === 'string') {
    error = new Error(error);
    error.name = 'MockError';
  }
  props = props || {};
  for (const key in props) {
    error[key] = props[key];
  }

  return error;
};

exports._mockError = function(mod, method, error, props, timeout, once) {
  if (typeof props === 'number') {
    timeout = props;
    props = {};
  }
  error = exports._createError(error, props);

  if (timeout) {
    timeout = parseInt(timeout, 10);
  }
  timeout = timeout || 0;
  mock(mod, method, thenify(function() {
    const callback = getCallback(arguments);
    setTimeout(function() {
      if (once) {
        exports.restore();
      }
      callback(error);
    }, timeout);
  }));
  return this;
};

/**
 * Mock async function error.
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {String|Error} error, error string message or error instance.
 * @param {Object} props, error properties
 * @param {Number} timeout, mock async callback timeout, default is 0.
 * @return {mm} this - mm
 */
exports.error = function(mod, method, error, props, timeout) {
  return exports._mockError(mod, method, error, props, timeout);
};

/**
 * Mock async function error once.
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {String|Error} error, error string message or error instance.
 * @param {Object} props, error properties
 * @param {Number} timeout, mock async callback timeout, default is 0.
 * @return {mm} this - mm
 */
exports.errorOnce = function(mod, method, error, props, timeout) {
  return exports._mockError(mod, method, error, props, timeout, true);
};

/**
 * mock return callback(null, data1, data2).
 *
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {Array} datas, return datas array.
 * @param {Number} timeout, mock async callback timeout, default is 10.
 * @return {mm} this - mm
 */
exports.datas = function(mod, method, datas, timeout) {
  if (timeout) {
    timeout = parseInt(timeout, 10);
  }
  timeout = timeout || 0;
  if (!Array.isArray(datas)) {
    datas = [ datas ];
  }
  mock(mod, method, thenify(function() {
    const callback = getCallback(arguments);
    setTimeout(function() {
      callback.apply(mod, [ null ].concat(datas));
    }, timeout);
  }));
  return this;
};

/**
 * mock return callback(null, data).
 *
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {Object} data, return data.
 * @param {Number} timeout, mock async callback timeout, default is 0.
 * @return {mm} this - mm
 */
exports.data = function(mod, method, data, timeout) {
  return exports.datas(mod, method, [ data ], timeout);
};

/**
 * mock return callback(null, null).
 *
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {Number} [timeout], mock async callback timeout, default is 0.
 * @return {mm} this - mm
 */
exports.empty = function(mod, method, timeout) {
  return exports.datas(mod, method, null, timeout);
};

/**
 * spy a function
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 */
exports.spy = function(mod, method) {
  if (typeof mod[method] !== 'function') throw new Error(`spy target ${method} is not a function`);
  mock(mod, method, mod[method]);
};

/**
 * mock function sync throw error
 *
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {String|Error} error, error string message or error instance.
 * @param {Object} [props], error properties
 */
exports.syncError = function(mod, method, error, props) {
  error = exports._createError(error, props);
  mock(mod, method, function() {
    throw error;
  });
};

/**
 * mock function sync return data
 *
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 * @param {Object} data, return data.
 */
exports.syncData = function(mod, method, data) {
  mock(mod, method, function() {
    return data;
  });
};

/**
 * mock function sync return nothing
 *
 * @param {Object} mod, module object
 * @param {String} method, mock module object method name.
 */
exports.syncEmpty = function(mod, method) {
  exports.syncData(mod, method);
};

exports.http = {};
exports.https = {};

function matchURL(options, params) {
  const url = params && params.url || params;
  const host = params && params.host;

  const pathname = options.path || options.pathname;
  const hostname = options.host || options.hostname;
  let match = false;
  if (pathname) {
    if (!url) {
      match = true;
    } else if (typeof url === 'string') {
      match = pathname === url;
    } else if (url instanceof RegExp) {
      match = url.test(pathname);
    } else if (typeof host === 'string') {
      match = host === hostname;
    } else if (host instanceof RegExp) {
      match = host.test(hostname);
    }
  }
  return match;
}

function mockRequest() {
  const req = new Duplex({
    write() {},
    read() {},
  });
  req.abort = function() {
    req._aborted = true;
    process.nextTick(function() {
      const err = new Error('socket hang up');
      err.code = 'ECONNRESET';
      req.emit('error', err);
    });
  };
  req.socket = {};
  return req;
}

/**
 * Mock http.request().
 * @param {String|RegExp|Object} url, request url path.
 *   If url is Object, should be {url: $url, host: $host}
 * @param {String|Buffer|ReadStream} data, mock response data.
 *   If data is Array, then res will emit `data` event many times.
 * @param {Object} headers, mock response headers.
 * @param {Number} [delay], response delay time, default is 10.
 * @return {mm} this - mm
 */
exports.http.request = function(url, data, headers, delay) {
  backupOriginalRequest(http);
  return _request.call(this, http, url, data, headers, delay);
};

/**
 * Mock https.request().
 * @param {String|RegExp|Object} url, request url path.
 *   If url is Object, should be {url: $url, host: $host}
 * @param {String|Buffer|ReadStream} data, mock response data.
 *   If data is Array, then res will emit `data` event many times.
 * @param {Object} headers, mock response headers.
 * @param {Number} [delay], response delay time, default is 0.
 * @return {mm} this - mm
 */
exports.https.request = function(url, data, headers, delay) {
  backupOriginalRequest(https);
  return _request.call(this, https, url, data, headers, delay);
};

function backupOriginalRequest(mod) {
  if (!mod.__sourceRequest) {
    mod.__sourceRequest = mod.request;
  }
  if (!mod.__sourceGet) {
    mod.__sourceGet = mod.get;
  }
}

function _request(mod, url, data, headers, delay) {
  headers = headers || {};
  if (delay) {
    delay = parseInt(delay, 10);
  }
  delay = delay || 0;

  mod.get = function(options, callback) {
    const req = mod.request(options, callback);
    req.end();
    return req;
  };

  mod.request = function(options, callback) {
    let datas = [];
    let stream = null; // read stream
    if (typeof data.read === 'function') {
      stream = data;
    } else if (!Array.isArray(data)) {
      datas = [ data ];
    } else {
      for (let i = 0; i < data.length; i++) {
        datas.push(data[i]);
      }
    }

    const match = matchURL(options, url);
    if (!match) {
      return mod.__sourceRequest(options, callback);
    }

    const req = mockRequest();

    if (callback) {
      req.on('response', callback);
    }

    let res;
    if (stream) {
      res = stream;
    } else {
      res = new Readable({
        read() {
          let chunk = datas.shift();
          if (!chunk) {
            if (!req._aborted) {
              this.push(null);
            }
            return;
          }

          if (!req._aborted) {
            if (typeof chunk === 'string') {
              chunk = Buffer.from ? Buffer.from(chunk) : new Buffer(chunk);
            }
            if (this.charset) {
              chunk = chunk.toString(this.charset);
            }
            this.push(chunk);
          }
        },
      });
      res.setEncoding = function(charset) {
        res.charset = charset;
      };
    }

    res.statusCode = headers.statusCode || 200;
    res.headers = omit(headers, 'statusCode');
    res.socket = req.socket;

    function sendResponse() {
      if (!req._aborted) {
        req.emit('response', res);
      }
    }

    if (delay) {
      setTimeout(sendResponse, delay);
    } else {
      setImmediate(sendResponse);
    }

    return req;
  };
  return this;
}

/**
 * Mock http.request() error.
 * @param {String|RegExp} url, request url path.
 * @param {String|Error} reqError, request error.
 * @param {String|Error} resError, response error.
 * @param {Number} [delay], request error delay time, default is 0.
 */
exports.http.requestError = function(url, reqError, resError, delay) {
  backupOriginalRequest(http);
  _requestError.call(this, http, url, reqError, resError, delay);
};

/**
 * Mock https.request() error.
 * @param {String|RegExp} url, request url path.
 * @param {String|Error} reqError, request error.
 * @param {String|Error} resError, response error.
 * @param {Number} [delay], request error delay time, default is 0.
 */
exports.https.requestError = function(url, reqError, resError, delay) {
  backupOriginalRequest(https);
  _requestError.call(this, https, url, reqError, resError, delay);
};

function _requestError(mod, url, reqError, resError, delay) {
  if (delay) {
    delay = parseInt(delay, 10);
  }
  delay = delay || 0;
  if (reqError && typeof reqError === 'string') {
    reqError = new Error(reqError);
    reqError.name = 'MockHttpRequestError';
  }
  if (resError && typeof resError === 'string') {
    resError = new Error(resError);
    resError.name = 'MockHttpResponseError';
  }

  mod.get = function(options, callback) {
    const req = mod.request(options, callback);
    req.end();
    return req;
  };

  mod.request = function(options, callback) {
    const match = matchURL(options, url);
    if (!match) {
      return mod.__sourceRequest(options, callback);
    }

    const req = mockRequest();

    if (callback) {
      req.on('response', callback);
    }

    setTimeout(function() {
      if (reqError) {
        return req.emit('error', reqError);
      }

      const res = new Duplex({
        read() {},
        write() {},
      });
      res.socket = req.socket;
      res.statusCode = 200;
      res.headers = {
        server: 'MockMateServer',
      };
      process.nextTick(function() {
        if (!req._aborted) {
          req.emit('error', resError);
        }
      });
      if (!req._aborted) {
        req.emit('response', res);
      }
    }, delay);

    return req;
  };
  return this;
}

/**
 * mock child_process spawn
 * @param {Integer} code exit code
 * @param {String} stdout stdout
 * @param {String} stderr stderr
 * @param {Integer} timeout stdout/stderr/close event emit timeout
 */
exports.spawn = function(code, stdout, stderr, timeout) {
  const evt = new EventEmitter();
  mock(cp, 'spawn', function() {
    return evt;
  });
  setTimeout(function() {
    stdout && evt.emit('stdout', stdout);
    stderr && evt.emit('stderr', stderr);
    evt.emit('close', code);
    evt.emit('exit', code);
  }, timeout);
};

/**
 * remove all mock effects.
 * @return {mm} this - mm
 */
exports.restore = function() {
  if (http.__sourceRequest) {
    http.request = http.__sourceRequest;
    http.__sourceRequest = null;
  }
  if (http.__sourceGet) {
    http.get = http.__sourceGet;
    http.__sourceGet = null;
  }

  if (https.__sourceRequest) {
    https.request = https.__sourceRequest;
    https.__sourceRequest = null;
  }

  muk.restore();
  return this;
};

function omit(obj, key) {
  const newObj = {};
  for (const k in obj) {
    if (k !== key) {
      newObj[k] = obj[k];
    }
  }
  return newObj;
}