eslint-plugin-jest 26.3.0 → 26.4.2

package/lib/rules/prefer-lowercase-title.js

@@ -9,18 +9,6 @@ var _utils = require("./utils");
 
 const hasStringAsFirstArgument = node => node.arguments[0] && (0, _utils.isStringNode)(node.arguments[0]);
 
-const findNodeNameAndArgument = (node, scope) => {
-  if (!((0, _utils.isTestCaseCall)(node, scope) || (0, _utils.isDescribeCall)(node, scope))) {
-    return null;
-  }
-
-  if (!hasStringAsFirstArgument(node)) {
-    return null;
-  }
-
-  return [(0, _utils.getNodeName)(node).split('.')[0], node.arguments[0]];
-};
-
 const populateIgnores = ignore => {
   const ignores = [];
 
@@ -93,22 +81,23 @@ var _default = (0, _utils.createRule)({
     return {
       CallExpression(node) {
         const scope = context.getScope();
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, scope);
 
-        if ((0, _utils.isDescribeCall)(node, scope)) {
+        if (!jestFnCall || !hasStringAsFirstArgument(node)) {
+          return;
+        }
+
+        if (jestFnCall.type === 'describe') {
           numberOfDescribeBlocks++;
 
           if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1) {
             return;
           }
-        }
-
-        const results = findNodeNameAndArgument(node, scope);
-
-        if (!results) {
+        } else if (jestFnCall.type !== 'test') {
           return;
         }
 
-        const [name, firstArg] = results;
+        const [firstArg] = node.arguments;
         const description = (0, _utils.getStringValue)(firstArg);
 
         if (allowedPrefixes.some(name => description.startsWith(name))) {
@@ -117,7 +106,7 @@ var _default = (0, _utils.createRule)({
 
         const firstCharacter = description.charAt(0);
 
-        if (!firstCharacter || firstCharacter === firstCharacter.toLowerCase() || ignores.includes(name)) {
+        if (!firstCharacter || firstCharacter === firstCharacter.toLowerCase() || ignores.includes(jestFnCall.name)) {
           return;
         }
 
@@ -125,7 +114,7 @@ var _default = (0, _utils.createRule)({
           messageId: 'unexpectedLowercase',
           node: node.arguments[0],
           data: {
-            method: name
+            method: jestFnCall.name
           },
 
           fix(fixer) {
@@ -139,7 +128,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node, context.getScope())) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context.getScope(), ['describe'])) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/prefer-snapshot-hint.js

@@ -108,7 +108,7 @@ var _default = (0, _utils.createRule)({
       'CallExpression:exit'(node) {
         const scope = context.getScope();
 
-        if ((0, _utils.isDescribeCall)(node, scope) || (0, _utils.isTestCaseCall)(node, scope)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, scope, ['describe', 'test'])) {
           var _depths$pop;
 
           /* istanbul ignore next */
@@ -119,7 +119,7 @@ var _default = (0, _utils.createRule)({
       CallExpression(node) {
         const scope = context.getScope();
 
-        if ((0, _utils.isDescribeCall)(node, scope) || (0, _utils.isTestCaseCall)(node, scope)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, scope, ['describe', 'test'])) {
           depths.push(expressionDepth);
           expressionDepth = 0;
         }

package/lib/rules/prefer-todo.js

@@ -17,12 +17,28 @@ function isEmptyFunction(node) {
   return node.body.type === _utils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
 }
 
-function createTodoFixer(node, fixer) {
-  const testName = (0, _utils2.getNodeName)(node).split('.').shift();
-  return fixer.replaceText(node.callee, `${testName}.todo`);
+function createTodoFixer(jestFnCall, fixer) {
+  const fixes = [fixer.replaceText(jestFnCall.head.node, `${jestFnCall.head.local}.todo`)];
+
+  if (jestFnCall.members.length) {
+    fixes.unshift(fixer.removeRange([jestFnCall.head.node.range[1], jestFnCall.members[0].range[1]]));
+  }
+
+  return fixes;
 }
 
-const isTargetedTestCase = (node, scope) => (0, _utils2.isTestCaseCall)(node, scope) && [_utils2.TestCaseName.it, _utils2.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils2.getNodeName)(node));
+const isTargetedTestCase = jestFnCall => {
+  if (jestFnCall.members.some(s => (0, _utils2.getAccessorValue)(s) !== 'skip')) {
+    return false;
+  } // todo: we should support this too (needs custom fixer)
+
+
+  if (jestFnCall.name.startsWith('x')) {
+    return false;
+  }
+
+  return !jestFnCall.name.startsWith('f');
+};
 
 var _default = (0, _utils2.createRule)({
   name: __filename,
@@ -46,8 +62,9 @@ var _default = (0, _utils2.createRule)({
     return {
       CallExpression(node) {
         const [title, callback] = node.arguments;
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context.getScope());
 
-        if (!title || !isTargetedTestCase(node, context.getScope()) || !(0, _utils2.isStringNode)(title)) {
+        if (!title || (jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'test' || !isTargetedTestCase(jestFnCall) || !(0, _utils2.isStringNode)(title)) {
           return;
         }
 
@@ -55,7 +72,7 @@ var _default = (0, _utils2.createRule)({
           context.report({
             messageId: 'emptyTest',
             node,
-            fix: fixer => [fixer.removeRange([title.range[1], callback.range[1]]), createTodoFixer(node, fixer)]
+            fix: fixer => [fixer.removeRange([title.range[1], callback.range[1]]), ...createTodoFixer(jestFnCall, fixer)]
           });
         }
 
@@ -63,7 +80,7 @@ var _default = (0, _utils2.createRule)({
           context.report({
             messageId: 'unimplementedTest',
             node,
-            fix: fixer => [createTodoFixer(node, fixer)]
+            fix: fixer => createTodoFixer(jestFnCall, fixer)
           });
         }
       }

package/lib/rules/require-hook.js

@@ -12,7 +12,7 @@ var _utils2 = require("./utils");
 const isJestFnCall = (node, scope) => {
   var _getNodeName;
 
-  if ((0, _utils2.isDescribeCall)(node, scope) || (0, _utils2.isTestCaseCall)(node, scope) || (0, _utils2.isHookCall)(node, scope)) {
+  if ((0, _utils2.parseJestFnCall)(node, scope)) {
     return true;
   }
 
@@ -100,7 +100,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if (!(0, _utils2.isDescribeCall)(node, context.getScope()) || node.arguments.length < 2) {
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context.getScope(), ['describe']) || node.arguments.length < 2) {
           return;
         }
 

package/lib/rules/require-top-level-describe.js

@@ -47,8 +47,13 @@ var _default = (0, _utils.createRule)({
     return {
       CallExpression(node) {
         const scope = context.getScope();
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, scope);
 
-        if ((0, _utils.isDescribeCall)(node, scope)) {
+        if (!jestFnCall) {
+          return;
+        }
+
+        if (jestFnCall.type === 'describe') {
           numberOfDescribeBlocks++;
 
           if (numberOfDescribeBlocks === 1) {
@@ -70,7 +75,7 @@ var _default = (0, _utils.createRule)({
         }
 
         if (numberOfDescribeBlocks === 0) {
-          if ((0, _utils.isTestCaseCall)(node, scope)) {
+          if (jestFnCall.type === 'test') {
             context.report({
               node,
               messageId: 'unexpectedTestCase'
@@ -78,7 +83,7 @@ var _default = (0, _utils.createRule)({
             return;
           }
 
-          if ((0, _utils.isHookCall)(node, scope)) {
+          if (jestFnCall.type === 'hook') {
             context.report({
               node,
               messageId: 'unexpectedHook'
@@ -89,7 +94,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node, context.getScope())) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context.getScope(), ['describe'])) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/utils/parseJestFnCall.js

@@ -0,0 +1,305 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodeChain = getNodeChain;
+exports.scopeHasLocalReference = exports.parseJestFnCall = exports.isTypeOfJestFnCall = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("../utils");
+
+const isTypeOfJestFnCall = (node, scope, types) => {
+  const jestFnCall = parseJestFnCall(node, scope);
+  return jestFnCall !== null && types.includes(jestFnCall.type);
+};
+
+exports.isTypeOfJestFnCall = isTypeOfJestFnCall;
+
+function getNodeChain(node) {
+  if ((0, _utils2.isSupportedAccessor)(node)) {
+    return [node];
+  }
+
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
+      return getNodeChain(node.tag);
+
+    case _utils.AST_NODE_TYPES.MemberExpression:
+      return [...getNodeChain(node.object), ...getNodeChain(node.property)];
+
+    case _utils.AST_NODE_TYPES.NewExpression:
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return getNodeChain(node.callee);
+  }
+
+  return [];
+}
+
+const determineJestFnType = name => {
+  // if (name === 'expect') {
+  //   return 'expect';
+  // }
+  if (name === 'jest') {
+    return 'jest';
+  }
+
+  if (_utils2.DescribeAlias.hasOwnProperty(name)) {
+    return 'describe';
+  }
+
+  if (_utils2.TestCaseName.hasOwnProperty(name)) {
+    return 'test';
+  }
+  /* istanbul ignore else */
+
+
+  if (_utils2.HookName.hasOwnProperty(name)) {
+    return 'hook';
+  }
+  /* istanbul ignore next */
+
+
+  return 'unknown';
+};
+
+const ValidJestFnCallChains = ['afterAll', 'afterEach', 'beforeAll', 'beforeEach', 'describe', 'describe.each', 'describe.only', 'describe.only.each', 'describe.skip', 'describe.skip.each', 'fdescribe', 'fdescribe.each', 'xdescribe', 'xdescribe.each', 'it', 'it.concurrent', 'it.concurrent.each', 'it.concurrent.only.each', 'it.concurrent.skip.each', 'it.each', 'it.failing', 'it.only', 'it.only.each', 'it.only.failing', 'it.skip', 'it.skip.each', 'it.skip.failing', 'it.todo', 'fit', 'fit.each', 'fit.failing', 'xit', 'xit.each', 'xit.failing', 'test', 'test.concurrent', 'test.concurrent.each', 'test.concurrent.only.each', 'test.concurrent.skip.each', 'test.each', 'test.failing', 'test.only', 'test.only.each', 'test.only.failing', 'test.skip', 'test.skip.each', 'test.skip.failing', 'test.todo', 'xtest', 'xtest.each', 'xtest.failing'];
+
+const parseJestFnCall = (node, scope) => {
+  var _node$parent, _node$parent2, _resolved$original;
+
+  // ensure that we're at the "top" of the function call chain otherwise when
+  // parsing e.g. x().y.z(), we'll incorrectly find & parse "x()" even though
+  // the full chain is not a valid jest function call chain
+  if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _utils.AST_NODE_TYPES.CallExpression || ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.type) === _utils.AST_NODE_TYPES.MemberExpression) {
+    return null;
+  }
+
+  const chain = getNodeChain(node);
+
+  if (chain.length === 0) {
+    return null;
+  } // ensure that the only call expression in the chain is at the end
+
+
+  if (chain.slice(0, chain.length - 1).some(nod => {
+    var _nod$parent;
+
+    return ((_nod$parent = nod.parent) === null || _nod$parent === void 0 ? void 0 : _nod$parent.type) === _utils.AST_NODE_TYPES.CallExpression;
+  })) {
+    return null;
+  }
+
+  const [first, ...rest] = chain;
+  const lastNode = chain[chain.length - 1]; // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+
+  if ((0, _utils2.isSupportedAccessor)(lastNode, 'each')) {
+    if (node.callee.type !== _utils.AST_NODE_TYPES.CallExpression && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+      return null;
+    }
+  }
+
+  const resolved = resolveToJestFn(scope, (0, _utils2.getAccessorValue)(first)); // we're not a jest function
+
+  if (!resolved) {
+    return null;
+  }
+
+  const name = (_resolved$original = resolved.original) !== null && _resolved$original !== void 0 ? _resolved$original : resolved.local;
+  const links = [name, ...rest.map(link => (0, _utils2.getAccessorValue)(link))];
+
+  if (name !== 'jest' && !ValidJestFnCallChains.includes(links.join('.'))) {
+    return null;
+  }
+
+  return {
+    name,
+    type: determineJestFnType(name),
+    head: { ...resolved,
+      node: first
+    },
+    members: rest
+  };
+};
+
+exports.parseJestFnCall = parseJestFnCall;
+
+const describeImportDefAsImport = def => {
+  if (def.parent.type === _utils.AST_NODE_TYPES.TSImportEqualsDeclaration) {
+    return null;
+  }
+
+  if (def.node.type !== _utils.AST_NODE_TYPES.ImportSpecifier) {
+    return null;
+  } // we only care about value imports
+
+
+  if (def.parent.importKind === 'type') {
+    return null;
+  }
+
+  return {
+    source: def.parent.source.value,
+    imported: def.node.imported.name,
+    local: def.node.local.name
+  };
+};
+/**
+ * Attempts to find the node that represents the import source for the
+ * given expression node, if it looks like it's an import.
+ *
+ * If no such node can be found (e.g. because the expression doesn't look
+ * like an import), then `null` is returned instead.
+ */
+
+
+const findImportSourceNode = node => {
+  if (node.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+    if (node.argument.type === _utils.AST_NODE_TYPES.ImportExpression) {
+      return node.argument.source;
+    }
+
+    return null;
+  }
+
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isIdentifier)(node.callee, 'require')) {
+    var _node$arguments$;
+
+    return (_node$arguments$ = node.arguments[0]) !== null && _node$arguments$ !== void 0 ? _node$arguments$ : null;
+  }
+
+  return null;
+};
+
+const describeVariableDefAsImport = def => {
+  var _def$name$parent;
+
+  // make sure that we've actually being assigned a value
+  if (!def.node.init) {
+    return null;
+  }
+
+  const sourceNode = findImportSourceNode(def.node.init);
+
+  if (!sourceNode || !(0, _utils2.isStringNode)(sourceNode)) {
+    return null;
+  }
+
+  if (((_def$name$parent = def.name.parent) === null || _def$name$parent === void 0 ? void 0 : _def$name$parent.type) !== _utils.AST_NODE_TYPES.Property) {
+    return null;
+  }
+
+  if (!(0, _utils2.isSupportedAccessor)(def.name.parent.key)) {
+    return null;
+  }
+
+  return {
+    source: (0, _utils2.getStringValue)(sourceNode),
+    imported: (0, _utils2.getAccessorValue)(def.name.parent.key),
+    local: def.name.name
+  };
+};
+/**
+ * Attempts to describe a definition as an import if possible.
+ *
+ * If the definition is an import binding, it's described as you'd expect.
+ * If the definition is a variable, then we try and determine if it's either
+ * a dynamic `import()` or otherwise a call to `require()`.
+ *
+ * If it's neither of these, `null` is returned to indicate that the definition
+ * is not describable as an import of any kind.
+ */
+
+
+const describePossibleImportDef = def => {
+  if (def.type === 'Variable') {
+    return describeVariableDefAsImport(def);
+  }
+
+  if (def.type === 'ImportBinding') {
+    return describeImportDefAsImport(def);
+  }
+
+  return null;
+};
+
+const collectReferences = scope => {
+  const locals = new Set();
+  const imports = new Map();
+  const unresolved = new Set();
+  let currentScope = scope;
+
+  while (currentScope !== null) {
+    for (const ref of currentScope.variables) {
+      if (ref.defs.length === 0) {
+        continue;
+      }
+
+      const def = ref.defs[ref.defs.length - 1];
+      const importDetails = describePossibleImportDef(def);
+
+      if (importDetails) {
+        imports.set(importDetails.local, importDetails);
+        continue;
+      }
+
+      locals.add(ref.name);
+    }
+
+    for (const ref of currentScope.through) {
+      unresolved.add(ref.identifier.name);
+    }
+
+    currentScope = currentScope.upper;
+  }
+
+  return {
+    locals,
+    imports,
+    unresolved
+  };
+};
+
+const resolveToJestFn = (scope, identifier) => {
+  const references = collectReferences(scope);
+  const maybeImport = references.imports.get(identifier);
+
+  if (maybeImport) {
+    // the identifier is imported from @jest/globals,
+    // so return the original import name
+    if (maybeImport.source === '@jest/globals') {
+      return {
+        original: maybeImport.imported,
+        local: maybeImport.local,
+        type: 'import'
+      };
+    }
+
+    return null;
+  } // the identifier was found as a local variable or function declaration
+  // meaning it's not a function from jest
+
+
+  if (references.locals.has(identifier)) {
+    return null;
+  }
+
+  return {
+    original: null,
+    local: identifier,
+    type: 'global'
+  };
+};
+
+const scopeHasLocalReference = (scope, referenceName) => {
+  const references = collectReferences(scope);
+  return (// referenceName was found as a local variable or function declaration.
+    references.locals.has(referenceName) || // referenceName was found as an imported identifier
+    references.imports.has(referenceName) || // referenceName was not found as an unresolved reference,
+    // meaning it is likely not an implicit global reference.
+    !references.unresolved.has(referenceName)
+  );
+};
+
+exports.scopeHasLocalReference = scopeHasLocalReference;