jest to mocha

jest to mocha

const methodMap = {
  suite: 'describe',
  context: 'describe',
  test: 'it',
  it: 'it',
  beforeAll: 'before',
  beforeEach: 'beforeEach',
  afterAll: 'after',
  afterEach: 'afterEach',
};

const jestMethodsWithDescriptionsAllowed = new Set(['it', 'test', 'describe']);

const methodModifiers = ['only', 'skip'];

function hasBinding(name, scope) {
  if (!scope) {
    return false;
  }

  const bindings = Object.keys(scope.getBindings()) || [];
  if (bindings.indexOf(name) >= 0) {
    return true;
  }

  return scope.isGlobal ? false : hasBinding(name, scope.parent);
}

function jestToMocha(fileInfo, api, options) {
  const j = api.jscodeshift;
  const ast = j(fileInfo.source);

  Object.keys(methodMap).forEach((mochaMethod) => {
    const jestMethod = methodMap[mochaMethod];

    ast
      .find(j.CallExpression, {
        type: 'CallExpression',
        callee: { type: 'Identifier', name: jestMethod },
      })
      .filter(({ scope }) => !hasBinding(jestMethod, scope))
      .replaceWith((path) => {
        let args = path.value.arguments;
        if (!jestMethodsWithDescriptionsAllowed.has(jestMethod)) {
          args = args.filter((a) => a.type !== 'Literal');
        } else if (args.length === 1 && args[0].type === 'Literal') {
          const emptyFunctionExpression = j.functionExpression(
            null,
            [],
            j.blockStatement([])
          );
          return j.callExpression(
            j.memberExpression(j.identifier(mochaMethod), j.identifier('skip')),
            args.concat([emptyFunctionExpression])
          );
        }
        return j.callExpression(j.identifier(mochaMethod), args);
      });

    methodModifiers.forEach((modifier) => {
      ast
        .find(j.CallExpression, {
          type: 'CallExpression',
          callee: {
            type: 'MemberExpression',
            object: { type: 'Identifier', name: jestMethod },
            property: { type: 'Identifier', name: modifier },
          },
        })
        .replaceWith((path) =>
          j.callExpression(
            j.memberExpression(j.identifier(mochaMethod), j.identifier(modifier)),
            path.value.arguments
          )
        );
    });
  });

  return ast.toSource();
}

export default jestToMocha;