@mock/require/node/index.js

Mock require

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

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

var _path = _interopRequireDefault(require("path"));

var _utils = require("@mock/utils");

var _getCallerFile = _interopRequireDefault(require("get-caller-file"));

const originalLoad = _utils.Module._load;
const mocksMap = new Map();
const createRequire = _utils.Module.createRequire || _utils.Module.createRequireFromPath;

const getMocks = module => {
  if (mocksMap.has(module.id)) {
    return mocksMap.get(module.id);
  }

  if (module.parent !== null && typeof module.parent !== 'undefined') {
    return getMocks(module.parent);
  }

  return null;
};

const mockRequire = (file, mocks) => {
  const callerFile = (0, _getCallerFile.default)();

  const callerDir = _path.default.dirname(callerFile);

  let fullPath = file;

  if (!_path.default.isAbsolute(file)) {
    const targetPath = _path.default.join(callerDir, file);

    fullPath = require.resolve(targetPath);
  }

  const resolve = createRequire(callerFile).resolve;

  require(fullPath);

  (0, _utils.uncacheKey)(fullPath);
  const fileMocks = new Map();

  for (const [request, value] of Object.entries(mocks)) {
    fileMocks.set(resolve(request), value);
  }

  if (!mocksMap.has(fullPath)) {
    mocksMap.set(fullPath, new Set());
  }

  mocksMap.get(fullPath).add(fileMocks);

  if (mocksMap.size === 1) {
    _utils.Module._load = (request, parent, isMain) => {
      const mocks = getMocks(parent);

      if (mocks !== null) {
        const requestKey = createRequire(parent.id).resolve(request);

        for (const mock of mocks) {
          if (mock.has(requestKey)) {
            const result = mock.get(requestKey);

            if (!_utils.Module.builtinModules.includes(request)) {
              Reflect.defineProperty(result, '__esModule', {
                value: true
              });
            }

            return result;
          }
        }
      }

      return originalLoad(request, parent, isMain);
    };
  }

  return () => {
    (0, _utils.uncacheKey)(fullPath);
    mocksMap.delete(fullPath);

    if (mocksMap.size === 0) {
      _utils.Module._load = originalLoad;
    }
  };
};

exports.mockRequire = mockRequire;