jest-codemods/dist/utils/proxyquire.js

Codemods for migrating test files to Jest

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = proxyquireTransformer;
var imports_1 = require("./imports");
var logger_1 = __importDefault(require("./logger"));
function findChildOfProgram(path, childPath) {
    if (childPath === void 0) { childPath = undefined; }
    if (path.value.type === 'Program') {
        return childPath;
    }
    return findChildOfProgram(path.parent, path);
}
var getJestMockStatement = function (_a) {
    var j = _a.j, mockName = _a.mockName, mockBody = _a.mockBody;
    return j.expressionStatement(j.callExpression(j.identifier('jest.mock'), [
        mockName,
        j.arrowFunctionExpression([], mockBody),
    ]));
};
function getIdentifierValue(ast, name) {
    var varDec = ast.findVariableDeclarators(name).get(0);
    if (varDec && 'value' in varDec.node.init) {
        return varDec.node.init.value;
    }
    return null;
}
function proxyquireTransformer(fileInfo, j, ast) {
    var importVariableName = (0, imports_1.removeRequireAndImport)(j, ast, 'proxyquire');
    if (importVariableName) {
        var mocks_1 = new Set();
        ast
            .find(j.CallExpression)
            .filter(function (path) {
            var match = path.value;
            if (match.callee.type === 'CallExpression' &&
                match.callee.callee.type === 'MemberExpression') {
                return match.callee.callee.object.name === importVariableName;
            }
            else if (match.callee.type === 'MemberExpression' &&
                match.callee.object.type === 'CallExpression' &&
                match.callee.object.callee.type === 'MemberExpression') {
                return match.callee.object.callee.object.name === importVariableName;
            }
            else if (match.callee.type === 'MemberExpression' &&
                match.callee.object.name === importVariableName) {
                var parent = path.parentPath.value;
                return parent && parent.type !== 'CallExpression';
            }
            return match.callee.name === importVariableName;
        })
            .forEach(function (outerCallExpression) {
            var args = outerCallExpression.node.arguments;
            if (args.length === 0) {
                // proxyquire is called with no arguments
                j(outerCallExpression).remove();
                return;
            }
            var pathArg = args[0];
            var requireFile = pathArg.type === 'Identifier'
                ? getIdentifierValue(ast, pathArg.name)
                : pathArg.value;
            var mocksNode = args[1];
            if (mocks_1.has(requireFile)) {
                (0, logger_1.default)(fileInfo, 'Multiple mocks of same file is not supported', outerCallExpression);
                return;
            }
            mocks_1.add(requireFile);
            if (mocksNode.type === 'ObjectExpression') {
                mocksNode.properties.forEach(function (o) {
                    var jestMockStatement = getJestMockStatement({
                        j: j,
                        mockName: o.key,
                        mockBody: o.value,
                    });
                    findChildOfProgram(outerCallExpression).insertBefore(jestMockStatement);
                });
            }
            else if (mocksNode.type === 'Identifier') {
                // Look for an ObjectExpression that defines the mocks
                var mocksObjectExpression_1;
                ast
                    .find(j.VariableDeclarator, {
                    id: { name: mocksNode.name },
                })
                    .filter(function (path) { return path.node.init.type === 'ObjectExpression'; })
                    .forEach(function (path) {
                    mocksObjectExpression_1 = path.node.init;
                });
                if (!mocksObjectExpression_1) {
                    (0, logger_1.default)(fileInfo, 'proxyrequire mocks not transformed due to missing declaration', outerCallExpression);
                    return;
                }
                mocksObjectExpression_1.properties.forEach(function (o) {
                    var mockName = o.key;
                    var jestMockStatement = getJestMockStatement({
                        j: j,
                        mockName: mockName,
                        mockBody: j.memberExpression(j.identifier(mocksNode.name), mockName),
                    });
                    findChildOfProgram(outerCallExpression).insertBefore(jestMockStatement);
                });
            }
            else {
                return;
            }
            var newCallExpressionNode = j.callExpression(j.identifier('require'), [
                j.literal(requireFile),
            ]);
            j(outerCallExpression).replaceWith(newCallExpressionNode);
        });
    }
}