eslint-plugin-jest 24.2.1 → 24.3.3

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## [24.3.3](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.2...v24.3.3) (2021-04-02)
+
+
+### Bug Fixes
+
+* **no-duplicate-hooks:** support `describe.each` ([#797](https://github.com/jest-community/eslint-plugin-jest/issues/797)) ([243cb4f](https://github.com/jest-community/eslint-plugin-jest/commit/243cb4f970e40aa195a3bffa0528dbdbfef7c4f5)), closes [#642](https://github.com/jest-community/eslint-plugin-jest/issues/642)
+* **prefer-expect-assertions:** support `.each` ([#798](https://github.com/jest-community/eslint-plugin-jest/issues/798)) ([f758243](https://github.com/jest-community/eslint-plugin-jest/commit/f75824359f2242f53997c59c238d83a59badeea3)), closes [#676](https://github.com/jest-community/eslint-plugin-jest/issues/676)
+
+## [24.3.2](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.1...v24.3.2) (2021-03-16)
+
+
+### Bug Fixes
+
+* **consistent-test-it:** properly handle `describe.each` ([#796](https://github.com/jest-community/eslint-plugin-jest/issues/796)) ([035bd30](https://github.com/jest-community/eslint-plugin-jest/commit/035bd30af43f1215e65bf1b26c2ef2e6d174d3c8)), closes [#795](https://github.com/jest-community/eslint-plugin-jest/issues/795)
+
+## [24.3.1](https://github.com/jest-community/eslint-plugin-jest/compare/v24.3.0...v24.3.1) (2021-03-13)
+
+
+### Bug Fixes
+
+* **no-focused-tests:** report on `skip` instead of `concurrent` ([#791](https://github.com/jest-community/eslint-plugin-jest/issues/791)) ([2b65b49](https://github.com/jest-community/eslint-plugin-jest/commit/2b65b491cea2c956e4ba314a809915b9ec62933b))
+
+# [24.3.0](https://github.com/jest-community/eslint-plugin-jest/compare/v24.2.1...v24.3.0) (2021-03-13)
+
+
+### Features
+
+* **unbound-method:** create rule ([#765](https://github.com/jest-community/eslint-plugin-jest/issues/765)) ([b1f4ed3](https://github.com/jest-community/eslint-plugin-jest/commit/b1f4ed3f6bb0264fdefb5138ba913fa2bacc725c))
+
 ## [24.2.1](https://github.com/jest-community/eslint-plugin-jest/compare/v24.2.0...v24.2.1) (2021-03-10)
 
 

package/README.md

@@ -128,7 +128,7 @@ installations requiring long-term consistency.
 
 ## Rules
 
-<!-- begin rules list -->
+<!-- begin base rules list -->
 
 | Rule                                                                         | Description                                                     | Configurations   | Fixable      |
 | ---------------------------------------------------------------------------- | --------------------------------------------------------------- | ---------------- | ------------ |
@@ -173,7 +173,32 @@ installations requiring long-term consistency.
 | [valid-expect-in-promise](docs/rules/valid-expect-in-promise.md)             | Enforce having return statement when testing with promises      | ![recommended][] |              |
 | [valid-title](docs/rules/valid-title.md)                                     | Enforce valid titles                                            | ![recommended][] | ![fixable][] |
 
-<!-- end rules list -->
+<!-- end base rules list -->
+
+## TypeScript Rules
+
+In addition to the above rules, this plugin also includes a few advanced rules
+that are powered by type-checking information provided by TypeScript.
+
+In order to use these rules, you must be using `@typescript-eslint/parser` &
+adjust your eslint config as outlined
+[here](https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/TYPED_LINTING.md)
+
+Note that unlike the type-checking rules in `@typescript-eslint/eslint-plugin`,
+the rules here will fallback to doing nothing if type information is not
+available, meaning its safe to include them in shared configs that could be used
+on JavaScript and TypeScript projects.
+
+Also note that `unbound-method` depends on `@typescript-eslint/eslint-plugin`,
+as it extends the original `unbound-method` rule from that plugin.
+
+<!-- begin type rules list -->
+
+| Rule                                           | Description                                                   | Configurations | Fixable |
+| ---------------------------------------------- | ------------------------------------------------------------- | -------------- | ------- |
+| [unbound-method](docs/rules/unbound-method.md) | Enforces unbound methods are called with their expected scope |                |         |
+
+<!-- end type rules list -->
 
 ## Credit
 

package/docs/rules/unbound-method.md

@@ -0,0 +1,54 @@
+# Enforces unbound methods are called with their expected scope (`unbound-method`)
+
+## Rule Details
+
+This rule extends the base [`@typescript-eslint/unbound-method`][original-rule]
+rule, meaning you must depend on `@typescript-eslint/eslint-plugin` for it to
+work. It adds support for understanding when it's ok to pass an unbound method
+to `expect` calls.
+
+See the [`@typescript-eslint` documentation][original-rule] for more details on
+the `unbound-method` rule.
+
+Note that while this rule requires type information to work, it will fail
+silently when not available allowing you to safely enable it on projects that
+are not using TypeScript.
+
+## How to use
+
+```json5
+{
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    ecmaVersion: 2020,
+    sourceType: 'module',
+  },
+  overrides: [
+    {
+      files: ['test/**'],
+      extends: ['jest'],
+      rules: {
+        // you should turn the original rule off *only* for test files
+        '@typescript-eslint/unbound-method': 'off',
+        'jest/unbound-method': 'error',
+      },
+    },
+  ],
+  rules: {
+    '@typescript-eslint/unbound-method': 'error',
+  },
+}
+```
+
+This rule should be applied to your test files in place of the original rule,
+which should be applied to the rest of your codebase.
+
+## Options
+
+See [`@typescript-eslint/unbound-method`][original-rule] options.
+
+<sup>Taken with ❤️ [from `@typescript-eslint` core][original-rule]</sup>
+
+[original-rule]:
+  https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/unbound-method.md

package/lib/rules/consistent-test-it.js

@@ -90,7 +90,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribe)(node)) {
+        if ((0, _utils.isDescribe)(node) && !(0, _utils.isEachCall)(node)) {
           describeNestingLevel--;
         }
       }

package/lib/rules/lowercase-name.js

@@ -17,9 +17,7 @@ const findNodeNameAndArgument = node => {
   }
 
   if ((0, _utils.isEachCall)(node)) {
-    var _node$parent;
-
-    if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && hasStringAsFirstArgument(node.parent)) {
+    if (node.parent.arguments.length > 0 && (0, _utils.isStringNode)(node.parent.arguments[0])) {
       return [node.callee.object.name, node.parent.arguments[0]];
     }
 

package/lib/rules/no-duplicate-hooks.js

@@ -55,7 +55,7 @@ var _default = (0, _utils.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isDescribe)(node)) {
+        if ((0, _utils.isDescribe)(node) && !(0, _utils.isEachCall)(node)) {
           hookContexts.pop();
         }
       }

package/lib/rules/no-focused-tests.js

@@ -63,7 +63,7 @@ var _default = (0, _utils.createRule)({
         if (calleeObject.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isCallToTestOnlyFunction(calleeObject)) {
           context.report({
             messageId: 'focusedTest',
-            node: calleeObject.property,
+            node: isConcurrentExpression(calleeObject) ? callee.property : calleeObject.property,
             suggest: [{
               messageId: 'suggestRemoveFocus',
 

package/lib/rules/prefer-expect-assertions.js

@@ -55,12 +55,24 @@ var _default = (0, _utils.createRule)({
 
   create(context, [options]) {
     return {
-      'CallExpression[callee.name=/^(it|test)$/][arguments.1.body.body]'(node) {
-        if (options.onlyFunctionsWithAsyncKeyword && !node.arguments[1].async) {
+      CallExpression(node) {
+        if (!(0, _utils.isTestCase)(node)) {
           return;
         }
 
-        const testFuncBody = node.arguments[1].body.body;
+        const args = (0, _utils.isEachCall)(node) ? node.parent.arguments : node.arguments;
+
+        if (args.length < 2) {
+          return;
+        }
+
+        const [, testFn] = args;
+
+        if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement || options.onlyFunctionsWithAsyncKeyword && !testFn.async) {
+          return;
+        }
+
+        const testFuncBody = testFn.body.body;
 
         if (!isFirstLineExprStmt(testFuncBody)) {
           context.report({
@@ -68,7 +80,7 @@ var _default = (0, _utils.createRule)({
             node,
             suggest: suggestions.map(([messageId, text]) => ({
               messageId,
-              fix: fixer => fixer.insertTextBeforeRange([node.arguments[1].body.range[0] + 1, node.arguments[1].body.range[1]], text)
+              fix: fixer => fixer.insertTextBeforeRange([testFn.body.range[0] + 1, testFn.body.range[1]], text)
             }))
           });
           return;

package/lib/rules/unbound-method.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+const toThrowMatchers = ['toThrow', 'toThrowError', 'toThrowErrorMatchingSnapshot', 'toThrowErrorMatchingInlineSnapshot'];
+
+const isJestExpectToThrowCall = node => {
+  if (!(0, _utils.isExpectCall)(node)) {
+    return false;
+  }
+
+  const {
+    matcher
+  } = (0, _utils.parseExpectCall)(node);
+
+  if (!matcher) {
+    return false;
+  }
+
+  return !toThrowMatchers.includes(matcher.name);
+};
+
+const baseRule = (() => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const TSESLintPlugin = require('@typescript-eslint/eslint-plugin');
+
+    return TSESLintPlugin.rules['unbound-method'];
+  } catch (e) {
+    const error = e;
+
+    if (error.code === 'MODULE_NOT_FOUND') {
+      return null;
+    }
+
+    throw error;
+  }
+})();
+
+const tryCreateBaseRule = context => {
+  try {
+    return baseRule === null || baseRule === void 0 ? void 0 : baseRule.create(context);
+  } catch {
+    return null;
+  }
+};
+
+var _default = (0, _utils.createRule)({
+  defaultOptions: [{
+    ignoreStatic: false
+  }],
+  ...baseRule,
+  name: __filename,
+  meta: {
+    messages: {
+      unbound: 'This rule requires `@typescript-eslint/eslint-plugin`'
+    },
+    schema: [],
+    type: 'problem',
+    ...(baseRule === null || baseRule === void 0 ? void 0 : baseRule.meta),
+    docs: {
+      category: 'Best Practices',
+      description: 'Enforces unbound methods are called with their expected scope',
+      requiresTypeChecking: true,
+      ...(baseRule === null || baseRule === void 0 ? void 0 : baseRule.meta.docs),
+      recommended: false
+    }
+  },
+
+  create(context) {
+    const baseSelectors = tryCreateBaseRule(context);
+
+    if (!baseSelectors) {
+      return {};
+    }
+
+    let inExpectToThrowCall = false;
+    return { ...baseSelectors,
+
+      CallExpression(node) {
+        inExpectToThrowCall = isJestExpectToThrowCall(node);
+      },
+
+      'CallExpression:exit'(node) {
+        if (inExpectToThrowCall && isJestExpectToThrowCall(node)) {
+          inExpectToThrowCall = false;
+        }
+      },
+
+      MemberExpression(node) {
+        var _baseSelectors$Member;
+
+        if (inExpectToThrowCall) {
+          return;
+        }
+
+        (_baseSelectors$Member = baseSelectors.MemberExpression) === null || _baseSelectors$Member === void 0 ? void 0 : _baseSelectors$Member.call(baseSelectors, node);
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/utils.js

@@ -403,18 +403,22 @@ exports.isTestCase = isTestCase;
 
 const isDescribe = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.name) || node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && node.callee.object.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.object.name) && node.callee.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeProperty.hasOwnProperty(node.callee.property.name) || node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.tag.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && node.callee.tag.object.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.tag.object.name);
 /**
- * Checks if the given node` is a call to `<describe|test|it>.each(...)`.
- * If `true`, the code must look like `<method>.each(...)`.
+ * Checks if the given node` is a call to `<describe|test|it>.each(...)()`.
+ * If `true`, the code must look like `<method>.each(...)()`.
  *
  * @param {JestFunctionCallExpression<DescribeAlias | TestCaseName>} node
  *
- * @return {node is JestFunctionCallExpressionWithMemberExpressionCallee<DescribeAlias | TestCaseName, DescribeProperty.each | TestCaseProperty.each>}
+ * @return {node is JestFunctionCallExpressionWithMemberExpressionCallee<DescribeAlias | TestCaseName, DescribeProperty.each | TestCaseProperty.each> & {parent: TSESTree.CallExpression}}
  */
 
 
 exports.isDescribe = isDescribe;
 
-const isEachCall = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, DescribeProperty.each);
+const isEachCall = node => {
+  var _node$parent;
+
+  return ((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, DescribeProperty.each);
+};
 /**
  * Gets the arguments of the given `JestFunctionCallExpression`.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "24.2.1",
+  "version": "24.3.3",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -62,7 +62,8 @@
         "displayName": "test",
         "testEnvironment": "node",
         "testPathIgnorePatterns": [
-          "<rootDir>/lib/.*"
+          "<rootDir>/lib/.*",
+          "<rootDir>/src/rules/__tests__/fixtures/*"
         ]
       },
       {
@@ -107,7 +108,7 @@
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.0.0",
-    "husky": "^5.1.3",
+    "husky": "^6.0.0",
     "is-ci": "^3.0.0",
     "jest": "^26.0.1",
     "jest-runner-eslint": "^0.10.0",
@@ -121,8 +122,14 @@
     "typescript": "^4.0.0"
   },
   "peerDependencies": {
+    "@typescript-eslint/eslint-plugin": ">= 4",
     "eslint": ">=5"
   },
+  "peerDependenciesMeta": {
+    "@typescript-eslint/eslint-plugin": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=10"
   },