jest-codemods/dist/transformers/should.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 = transformer;
var imports_1 = require("../utils/imports");
var line_terminator_1 = __importDefault(require("../utils/line-terminator"));
var quote_style_1 = __importDefault(require("../utils/quote-style"));
var recast_helpers_1 = require("../utils/recast-helpers");
var chai_should_1 = __importDefault(require("./chai-should"));
var assertionRemappings = {
    throws: 'throw',
};
function transformer(fileInfo, api, options) {
    var j = api.jscodeshift;
    var root = j(fileInfo.source);
    var isShouldMemberExpression = (0, recast_helpers_1.traverseMemberExpressionUtil)(j, function (node) {
        return (node.type === j.CallExpression.name && node.callee.name === 'should') ||
            (node.type === j.Identifier.name && node.name === 'should');
    });
    /**
     * Injects missing to prefixes expected by chai-should transformer.
     * TODO: not sure if this is even required for chai...
     */
    function injectMissingPrefix() {
        var injector = function (p) {
            var property = p.parentPath.value.property;
            if (property && property.type === j.Identifier.name) {
                if (property.name !== 'to') {
                    var newPath = j.memberExpression(p.value, j.identifier('to'));
                    p.replace(newPath);
                }
            }
        };
        root
            .find(j.CallExpression, {
            callee: {
                name: function (name) { return ['expect', 'should'].indexOf(name) >= 0; },
            },
        })
            .forEach(injector);
        root
            .find(j.MemberExpression, {
            property: {
                type: j.Identifier.name,
                name: 'should',
            },
        })
            .forEach(injector);
    }
    function renameShouldCallExpressions() {
        root
            .find(j.CallExpression, {
            callee: {
                name: 'should',
            },
        })
            .forEach(function (p) {
            p.value.callee.name = 'expect';
        });
    }
    function remapAssertions() {
        root
            .find(j.MemberExpression, {
            property: {
                name: function (name) { return Object.keys(assertionRemappings).indexOf(name) >= 0; },
            },
        })
            .filter(function (p) { return isShouldMemberExpression(p.value); })
            .forEach(function (p) {
            var property = p.value.property;
            property.name = assertionRemappings[property.name];
        });
    }
    (0, imports_1.removeRequireAndImport)(j, root, 'should');
    injectMissingPrefix();
    renameShouldCallExpressions();
    remapAssertions();
    var quote = (0, quote_style_1.default)(j, root) || 'single';
    var lineTerminator = (0, line_terminator_1.default)(fileInfo.source);
    fileInfo.source = root.toSource({ quote: quote, lineTerminator: lineTerminator });
    return (0, chai_should_1.default)(fileInfo, api, options);
}