eslint-plugin-jest 26.1.1 → 26.5.3

package/lib/rules/prefer-hooks-in-order.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+const HooksOrder = ['beforeAll', 'beforeEach', 'afterEach', 'afterAll'];
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer having hooks in a consistent order',
+      recommended: false
+    },
+    messages: {
+      reorderHooks: `\`{{ currentHook }}\` hooks should be before any \`{{ previousHook }}\` hooks`
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+
+  create(context) {
+    let previousHookIndex = -1;
+    let inHook = false;
+    return {
+      CallExpression(node) {
+        if (inHook) {
+          // Ignore everything that is passed into a hook
+          return;
+        }
+
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'hook') {
+          // Reset the previousHookIndex when encountering something different from a hook
+          previousHookIndex = -1;
+          return;
+        }
+
+        inHook = true;
+        const currentHook = jestFnCall.name;
+        const currentHookIndex = HooksOrder.indexOf(currentHook);
+
+        if (currentHookIndex < previousHookIndex) {
+          context.report({
+            messageId: 'reorderHooks',
+            node,
+            data: {
+              previousHook: HooksOrder[previousHookIndex],
+              currentHook
+            }
+          });
+          return;
+        }
+
+        previousHookIndex = currentHookIndex;
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['hook'])) {
+          inHook = false;
+          return;
+        }
+
+        if (inHook) {
+          return;
+        } // Reset the previousHookIndex when encountering something different from a hook
+
+
+        previousHookIndex = -1;
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-hooks-on-top.js

@@ -27,11 +27,11 @@ var _default = (0, _utils.createRule)({
     const hooksContext = [false];
     return {
       CallExpression(node) {
-        if (!(0, _utils.isHook)(node) && (0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['test'])) {
           hooksContext[hooksContext.length - 1] = true;
         }
 
-        if (hooksContext[hooksContext.length - 1] && (0, _utils.isHook)(node)) {
+        if (hooksContext[hooksContext.length - 1] && (0, _utils.isTypeOfJestFnCall)(node, context, ['hook'])) {
           context.report({
             messageId: 'noHookOnTop',
             node

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 => {
-  if (!((0, _utils.isTestCaseCall)(node) || (0, _utils.isDescribeCall)(node))) {
-    return null;
-  }
-
-  if (!hasStringAsFirstArgument(node)) {
-    return null;
-  }
-
-  return [(0, _utils.getNodeName)(node).split('.')[0], node.arguments[0]];
-};
-
 const populateIgnores = ignore => {
   const ignores = [];
 
@@ -92,21 +80,23 @@ var _default = (0, _utils.createRule)({
     let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if (!jestFnCall || !hasStringAsFirstArgument(node)) {
+          return;
+        }
+
+        if (jestFnCall.type === 'describe') {
           numberOfDescribeBlocks++;
 
           if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1) {
             return;
           }
-        }
-
-        const results = findNodeNameAndArgument(node);
-
-        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))) {
@@ -115,7 +105,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;
         }
 
@@ -123,7 +113,7 @@ var _default = (0, _utils.createRule)({
           messageId: 'unexpectedLowercase',
           node: node.arguments[0],
           data: {
-            method: name
+            method: jestFnCall.name
           },
 
           fix(fixer) {
@@ -137,7 +127,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
           numberOfDescribeBlocks--;
         }
       }

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

@@ -14,10 +14,26 @@ const isSnapshotMatcher = matcher => {
 };
 
 const isSnapshotMatcherWithoutHint = matcher => {
-  var _matcher$arguments;
+  if (!matcher.arguments || matcher.arguments.length === 0) {
+    return true;
+  } // this matcher only supports one argument which is the hint
 
-  const expectedNumberOfArgumentsWithHint = 1 + Number(matcher.name === 'toMatchSnapshot');
-  return ((_matcher$arguments = matcher.arguments) === null || _matcher$arguments === void 0 ? void 0 : _matcher$arguments.length) !== expectedNumberOfArgumentsWithHint;
+
+  if (matcher.name !== 'toMatchSnapshot') {
+    return matcher.arguments.length !== 1;
+  } // if we're being passed two arguments,
+  // the second one should be the hint
+
+
+  if (matcher.arguments.length === 2) {
+    return false;
+  }
+
+  const [arg] = matcher.arguments; // the first argument to `toMatchSnapshot` can be _either_ a snapshot hint or
+  // an object with asymmetric matchers, so we can't just assume that the first
+  // argument is a hint when it's by itself.
+
+  return !(0, _utils.isStringNode)(arg);
 };
 
 const messages = {
@@ -43,6 +59,7 @@ var _default = (0, _utils.createRule)({
 
   create(context, [mode]) {
     const snapshotMatchers = [];
+    const depths = [];
     let expressionDepth = 0;
 
     const reportSnapshotMatchersWithoutHints = () => {
@@ -88,7 +105,21 @@ var _default = (0, _utils.createRule)({
       ArrowFunctionExpression: enterExpression,
       'ArrowFunctionExpression:exit': exitExpression,
 
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe', 'test'])) {
+          var _depths$pop;
+
+          /* istanbul ignore next */
+          expressionDepth = (_depths$pop = depths.pop()) !== null && _depths$pop !== void 0 ? _depths$pop : 0;
+        }
+      },
+
       CallExpression(node) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe', 'test'])) {
+          depths.push(expressionDepth);
+          expressionDepth = 0;
+        }
+
         if (!(0, _utils.isExpectCall)(node)) {
           return;
         }

package/lib/rules/prefer-strict-equal.js

@@ -43,7 +43,7 @@ var _default = (0, _utils.createRule)({
             node: matcher.node.property,
             suggest: [{
               messageId: 'suggestReplaceWithStrictEqual',
-              fix: fixer => [fixer.replaceText(matcher.node.property, _utils.EqualityMatcher.toStrictEqual)]
+              fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, _utils.EqualityMatcher.toStrictEqual)]
             }]
           });
         }

package/lib/rules/prefer-to-be.js

@@ -44,7 +44,7 @@ const reportPreferToBe = (context, whatToBe, matcher, modifier) => {
     fix(fixer) {
       var _matcher$arguments;
 
-      const fixes = [fixer.replaceText(matcher.node.property, `toBe${whatToBe}`)];
+      const fixes = [(0, _utils2.replaceAccessorFixer)(fixer, matcher.node.property, `toBe${whatToBe}`)];
 
       if ((_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length && whatToBe !== '') {
         fixes.push(fixer.remove(matcher.arguments[0]));

package/lib/rules/prefer-todo.js

@@ -17,12 +17,26 @@ 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) {
+  if (jestFnCall.members.length) {
+    return (0, _utils2.replaceAccessorFixer)(fixer, jestFnCall.members[0], 'todo');
+  }
+
+  return fixer.replaceText(jestFnCall.head.node, `${jestFnCall.head.local}.todo`);
 }
 
-const isTargetedTestCase = node => (0, _utils2.isTestCaseCall)(node) && [_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 +60,9 @@ var _default = (0, _utils2.createRule)({
     return {
       CallExpression(node) {
         const [title, callback] = node.arguments;
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        if (!title || !isTargetedTestCase(node) || !(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 +70,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 +78,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

@@ -9,10 +9,10 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isJestFnCall = node => {
+const isJestFnCall = (node, context) => {
   var _getNodeName;
 
-  if ((0, _utils2.isDescribeCall)(node) || (0, _utils2.isTestCaseCall)(node) || (0, _utils2.isHook)(node)) {
+  if ((0, _utils2.parseJestFnCall)(node, context)) {
     return true;
   }
 
@@ -23,13 +23,13 @@ const isNullOrUndefined = node => {
   return node.type === _utils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils2.isIdentifier)(node, 'undefined');
 };
 
-const shouldBeInHook = (node, allowedFunctionCalls = []) => {
+const shouldBeInHook = (node, context, allowedFunctionCalls = []) => {
   switch (node.type) {
     case _utils.AST_NODE_TYPES.ExpressionStatement:
-      return shouldBeInHook(node.expression, allowedFunctionCalls);
+      return shouldBeInHook(node.expression, context, allowedFunctionCalls);
 
     case _utils.AST_NODE_TYPES.CallExpression:
-      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
+      return !(isJestFnCall(node, context) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
 
     case _utils.AST_NODE_TYPES.VariableDeclaration:
       {
@@ -85,7 +85,7 @@ var _default = (0, _utils2.createRule)({
 
     const checkBlockBody = body => {
       for (const statement of body) {
-        if (shouldBeInHook(statement, allowedFunctionCalls)) {
+        if (shouldBeInHook(statement, context, allowedFunctionCalls)) {
           context.report({
             node: statement,
             messageId: 'useHook'
@@ -100,7 +100,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if (!(0, _utils2.isDescribeCall)(node) || node.arguments.length < 2) {
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['describe']) || node.arguments.length < 2) {
           return;
         }
 

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

@@ -46,7 +46,13 @@ var _default = (0, _utils.createRule)({
     let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if (!jestFnCall) {
+          return;
+        }
+
+        if (jestFnCall.type === 'describe') {
           numberOfDescribeBlocks++;
 
           if (numberOfDescribeBlocks === 1) {
@@ -68,7 +74,7 @@ var _default = (0, _utils.createRule)({
         }
 
         if (numberOfDescribeBlocks === 0) {
-          if ((0, _utils.isTestCaseCall)(node)) {
+          if (jestFnCall.type === 'test') {
             context.report({
               node,
               messageId: 'unexpectedTestCase'
@@ -76,7 +82,7 @@ var _default = (0, _utils.createRule)({
             return;
           }
 
-          if ((0, _utils.isHook)(node)) {
+          if (jestFnCall.type === 'hook') {
             context.report({
               node,
               messageId: 'unexpectedHook'
@@ -87,7 +93,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribeCall)(node)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe'])) {
           numberOfDescribeBlocks--;
         }
       }

package/lib/rules/utils/accessors.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isSupportedAccessor = exports.isStringNode = exports.isIdentifier = exports.getStringValue = exports.getAccessorValue = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+/**
+ * Checks if the given `node` is a `StringLiteral`.
+ *
+ * If a `value` is provided & the `node` is a `StringLiteral`,
+ * the `value` will be compared to that of the `StringLiteral`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is StringLiteral<V>}
+ *
+ * @template V
+ */
+const isStringLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
+
+/**
+ * Checks if the given `node` is a `TemplateLiteral`.
+ *
+ * Complex `TemplateLiteral`s are not considered specific, and so will return `false`.
+ *
+ * If a `value` is provided & the `node` is a `TemplateLiteral`,
+ * the `value` will be compared to that of the `TemplateLiteral`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is TemplateLiteral<V>}
+ *
+ * @template V
+ */
+const isTemplateLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
+value === undefined || node.quasis[0].value.raw === value);
+
+/**
+ * Checks if the given `node` is a {@link StringNode}.
+ *
+ * @param {Node} node
+ * @param {V} [specifics]
+ *
+ * @return {node is StringNode}
+ *
+ * @template V
+ */
+const isStringNode = (node, specifics) => isStringLiteral(node, specifics) || isTemplateLiteral(node, specifics);
+/**
+ * Gets the value of the given `StringNode`.
+ *
+ * If the `node` is a `TemplateLiteral`, the `raw` value is used;
+ * otherwise, `value` is returned instead.
+ *
+ * @param {StringNode<S>} node
+ *
+ * @return {S}
+ *
+ * @template S
+ */
+
+
+exports.isStringNode = isStringNode;
+
+const getStringValue = node => isTemplateLiteral(node) ? node.quasis[0].value.raw : node.value;
+/**
+ * An `Identifier` with a known `name` value - i.e `expect`.
+ */
+
+
+exports.getStringValue = getStringValue;
+
+/**
+ * Checks if the given `node` is an `Identifier`.
+ *
+ * If a `name` is provided, & the `node` is an `Identifier`,
+ * the `name` will be compared to that of the `identifier`.
+ *
+ * @param {Node} node
+ * @param {V} [name]
+ *
+ * @return {node is KnownIdentifier<Name>}
+ *
+ * @template V
+ */
+const isIdentifier = (node, name) => node.type === _utils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
+/**
+ * Checks if the given `node` is a "supported accessor".
+ *
+ * This means that it's a node can be used to access properties,
+ * and who's "value" can be statically determined.
+ *
+ * `MemberExpression` nodes most commonly contain accessors,
+ * but it's possible for other nodes to contain them.
+ *
+ * If a `value` is provided & the `node` is an `AccessorNode`,
+ * the `value` will be compared to that of the `AccessorNode`.
+ *
+ * Note that `value` here refers to the normalised value.
+ * The property that holds the value is not always called `name`.
+ *
+ * @param {Node} node
+ * @param {V} [value]
+ *
+ * @return {node is AccessorNode<V>}
+ *
+ * @template V
+ */
+
+
+exports.isIdentifier = isIdentifier;
+
+const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStringNode(node, value);
+/**
+ * Gets the value of the given `AccessorNode`,
+ * account for the different node types.
+ *
+ * @param {AccessorNode<S>} accessor
+ *
+ * @return {S}
+ *
+ * @template S
+ */
+
+
+exports.isSupportedAccessor = isSupportedAccessor;
+
+const getAccessorValue = accessor => accessor.type === _utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
+
+exports.getAccessorValue = getAccessorValue;

package/lib/rules/utils/followTypeAssertionChain.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.followTypeAssertionChain = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+const isTypeCastExpression = node => node.type === _utils.AST_NODE_TYPES.TSAsExpression || node.type === _utils.AST_NODE_TYPES.TSTypeAssertion;
+
+const followTypeAssertionChain = expression => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
+
+exports.followTypeAssertionChain = followTypeAssertionChain;

package/lib/rules/utils/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _accessors = require("./accessors");
+
+Object.keys(_accessors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _accessors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _accessors[key];
+    }
+  });
+});
+
+var _detectJestVersion = require("./detectJestVersion");
+
+Object.keys(_detectJestVersion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _detectJestVersion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _detectJestVersion[key];
+    }
+  });
+});
+
+var _followTypeAssertionChain = require("./followTypeAssertionChain");
+
+Object.keys(_followTypeAssertionChain).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _followTypeAssertionChain[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _followTypeAssertionChain[key];
+    }
+  });
+});
+
+var _misc = require("./misc");
+
+Object.keys(_misc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _misc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _misc[key];
+    }
+  });
+});
+
+var _parseJestFnCall = require("./parseJestFnCall");
+
+Object.keys(_parseJestFnCall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseJestFnCall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseJestFnCall[key];
+    }
+  });
+});
+
+var _parseExpectCall = require("./parseExpectCall");
+
+Object.keys(_parseExpectCall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseExpectCall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseExpectCall[key];
+    }
+  });
+});