eslint-plugin-jest 28.5.0 → 28.6.0

package/README.md

@@ -307,10 +307,15 @@ enabled in.\
 set to warn in.\
 ✅ Set in the `recommended`
 [configuration](https://github.com/jest-community/eslint-plugin-jest/blob/main/README.md#shareable-configurations).\
-🎨 Set in the `style` [configuration](https://github.com/jest-community/eslint-plugin-jest/blob/main/README.md#shareable-configurations).\
-🔧 Automatically fixable by the
+🎨
+Set in the `style`
+[configuration](https://github.com/jest-community/eslint-plugin-jest/blob/main/README.md#shareable-configurations).\
+🔧
+Automatically fixable by the
 [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
-💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+💡
+Manually fixable by
+[editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
 | Name                                                                         | Description                                                               | 💼  | ⚠️  | 🔧  | 💡  |
 | :--------------------------------------------------------------------------- | :------------------------------------------------------------------------ | :-- | :-- | :-- | :-- |
@@ -350,6 +355,7 @@ set to warn in.\
 | [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                                 |     |     |     |     |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                                |     |     |     |     |
 | [prefer-importing-jest-globals](docs/rules/prefer-importing-jest-globals.md) | Prefer importing Jest globals                                             |     |     | 🔧  |     |
+| [prefer-jest-mocked](docs/rules/prefer-jest-mocked.md)                       | Prefer `jest.mocked()` over `fn as jest.Mock`                             |     |     | 🔧  |     |
 | [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                              |     |     | 🔧  |     |
 | [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md) | Prefer mock resolved/rejected shorthands for promises                     |     |     | 🔧  |     |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                           |     |     |     |     |

package/docs/rules/prefer-jest-mocked.md

@@ -0,0 +1,38 @@
+# Prefer `jest.mocked()` over `fn as jest.Mock` (`prefer-jest-mocked`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+When working with mocks of functions using Jest, it's recommended to use the
+`jest.mocked()` helper function to properly type the mocked functions. This rule
+enforces the use of `jest.mocked()` for better type safety and readability.
+
+Restricted types:
+
+- `jest.Mock`
+- `jest.MockedFunction`
+- `jest.MockedClass`
+- `jest.MockedObject`
+
+## Rule details
+
+The following patterns are warnings:
+
+```typescript
+(foo as jest.Mock).mockReturnValue(1);
+const mock = (foo as jest.Mock).mockReturnValue(1);
+(foo as unknown as jest.Mock).mockReturnValue(1);
+(Obj.foo as jest.Mock).mockReturnValue(1);
+([].foo as jest.Mock).mockReturnValue(1);
+```
+
+The following patterns are not warnings:
+
+```js
+jest.mocked(foo).mockReturnValue(1);
+const mock = jest.mocked(foo).mockReturnValue(1);
+jest.mocked(Obj.foo).mockReturnValue(1);
+jest.mocked([].foo).mockReturnValue(1);
+```

package/lib/index.js

@@ -4,7 +4,7 @@ var _fs = require("fs");
 var _path = require("path");
 var _package = require("../package.json");
 var _globals = _interopRequireDefault(require("./globals.json"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // copied from https://github.com/babel/babel/blob/d8da63c929f2d28c401571e2a43166678c555bc4/packages/babel-helpers/src/helpers.js#L602-L606
 /* istanbul ignore next */
 const interopRequireDefault = obj => obj && obj.__esModule ? obj : {

package/lib/rules/prefer-jest-mocked.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const mockTypes = ['Mock', 'MockedFunction', 'MockedClass', 'MockedObject'];
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer `jest.mocked()` over `fn as jest.Mock`'
+    },
+    messages: {
+      useJestMocked: 'Prefer `jest.mocked()`'
+    },
+    schema: [],
+    type: 'suggestion',
+    fixable: 'code'
+  },
+  defaultOptions: [],
+  create(context) {
+    function check(node) {
+      const {
+        typeAnnotation
+      } = node;
+      if (typeAnnotation.type !== _utils.AST_NODE_TYPES.TSTypeReference) {
+        return;
+      }
+      const {
+        typeName
+      } = typeAnnotation;
+      if (typeName.type !== _utils.AST_NODE_TYPES.TSQualifiedName) {
+        return;
+      }
+      const {
+        left,
+        right
+      } = typeName;
+      if (left.type !== _utils.AST_NODE_TYPES.Identifier || right.type !== _utils.AST_NODE_TYPES.Identifier || left.name !== 'jest' || !mockTypes.includes(right.name)) {
+        return;
+      }
+      const fnName = (0, _utils2.getSourceCode)(context).text.slice(...(0, _utils2.followTypeAssertionChain)(node.expression).range);
+      context.report({
+        node: node,
+        messageId: 'useJestMocked',
+        fix(fixer) {
+          return fixer.replaceText(node, `jest.mocked(${fnName})`);
+        }
+      });
+    }
+    return {
+      TSAsExpression(node) {
+        if (node.parent.type === _utils.AST_NODE_TYPES.TSAsExpression) {
+          return;
+        }
+        check(node);
+      },
+      TSTypeAssertion(node) {
+        check(node);
+      }
+    };
+  }
+});

package/lib/rules/valid-expect.js

@@ -28,13 +28,19 @@ const getPromiseCallExpressionNode = node => {
   return null;
 };
 const findPromiseCallExpressionNode = node => node.parent?.parent && [_utils.AST_NODE_TYPES.CallExpression, _utils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
-const findFirstAsyncFunction = ({
+const findFirstFunctionExpression = ({
   parent
 }) => {
   if (!parent) {
     return null;
   }
-  return (0, _utils2.isFunction)(parent) && parent.async ? parent : findFirstAsyncFunction(parent);
+  return (0, _utils2.isFunction)(parent) ? parent : findFirstFunctionExpression(parent);
+};
+const getNormalizeFunctionExpression = functionExpression => {
+  if (functionExpression.parent.type === _utils.AST_NODE_TYPES.Property && functionExpression.type === _utils.AST_NODE_TYPES.FunctionExpression) {
+    return functionExpression.parent;
+  }
+  return functionExpression;
 };
 const getParentIfThenified = node => {
   const grandParentNode = node.parent?.parent;
@@ -114,6 +120,7 @@ var _default = exports.default = (0, _utils2.createRule)({
   }]) {
     // Context state
     const arrayExceptions = new Set();
+    const descriptors = [];
     const pushPromiseArrayException = loc => arrayExceptions.add(promiseArrayExceptionKey(loc));
 
     /**
@@ -224,7 +231,7 @@ var _default = exports.default = (0, _utils2.createRule)({
         } = jestFnCall;
         const parentNode = matcher.parent.parent;
         const shouldBeAwaited = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) !== 'not') || asyncMatchers.includes((0, _utils2.getAccessorValue)(matcher));
-        if (!parentNode?.parent || !shouldBeAwaited) {
+        if (!parentNode.parent || !shouldBeAwaited) {
           return;
         }
         /**
@@ -232,7 +239,6 @@ var _default = exports.default = (0, _utils2.createRule)({
          * for the array object, not for each individual assertion.
          */
         const isParentArrayExpression = parentNode.parent.type === _utils.AST_NODE_TYPES.ArrayExpression;
-        const orReturned = alwaysAwait ? '' : ' or returned';
         /**
          * An async assertion can be chained with `then` or `catch` statements.
          * In that case our target CallExpression node is the one with
@@ -245,30 +251,51 @@ var _default = exports.default = (0, _utils2.createRule)({
         !isAcceptableReturnNode(finalNode.parent, !alwaysAwait) &&
         // if we didn't warn user already
         !promiseArrayExceptionExists(finalNode.loc)) {
+          descriptors.push({
+            node: finalNode,
+            messageId: targetNode === finalNode ? 'asyncMustBeAwaited' : 'promisesWithAsyncAssertionsMustBeAwaited'
+          });
+        }
+        if (isParentArrayExpression) {
+          pushPromiseArrayException(finalNode.loc);
+        }
+      },
+      'Program:exit'() {
+        const fixes = [];
+        descriptors.forEach(({
+          node,
+          messageId
+        }, index) => {
+          const orReturned = alwaysAwait ? '' : ' or returned';
           context.report({
-            loc: finalNode.loc,
+            loc: node.loc,
             data: {
               orReturned
             },
-            messageId: finalNode === targetNode ? 'asyncMustBeAwaited' : 'promisesWithAsyncAssertionsMustBeAwaited',
+            messageId,
             node,
             fix(fixer) {
-              if (!findFirstAsyncFunction(finalNode)) {
-                return [];
+              const functionExpression = findFirstFunctionExpression(node);
+              if (!functionExpression) {
+                return null;
+              }
+              const foundAsyncFixer = fixes.some(fix => fix.text === 'async ');
+              if (!functionExpression.async && !foundAsyncFixer) {
+                const targetFunction = getNormalizeFunctionExpression(functionExpression);
+                fixes.push(fixer.insertTextBefore(targetFunction, 'async '));
               }
-              const returnStatement = finalNode.parent?.type === _utils.AST_NODE_TYPES.ReturnStatement ? finalNode.parent : null;
+              const returnStatement = node.parent?.type === _utils.AST_NODE_TYPES.ReturnStatement ? node.parent : null;
               if (alwaysAwait && returnStatement) {
                 const sourceCodeText = (0, _utils2.getSourceCode)(context).getText(returnStatement);
                 const replacedText = sourceCodeText.replace('return', 'await');
-                return fixer.replaceText(returnStatement, replacedText);
+                fixes.push(fixer.replaceText(returnStatement, replacedText));
+              } else {
+                fixes.push(fixer.insertTextBefore(node, 'await '));
               }
-              return fixer.insertTextBefore(finalNode, 'await ');
+              return index === descriptors.length - 1 ? fixes : null;
             }
           });
-          if (isParentArrayExpression) {
-            pushPromiseArrayException(finalNode.loc);
-          }
-        }
+        });
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "28.5.0",
+  "version": "28.6.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -48,13 +48,6 @@
     "singleQuote": true
   },
   "release": {
-    "branches": [
-      "main",
-      {
-        "name": "next",
-        "prerelease": true
-      }
-    ],
     "plugins": [
       "@semantic-release/commit-analyzer",
       "@semantic-release/release-notes-generator",
@@ -106,7 +99,7 @@
     "pinst": "^3.0.0",
     "prettier": "^3.0.0",
     "rimraf": "^5.0.0",
-    "semantic-release": "^23.0.0",
+    "semantic-release": "^24.0.0",
     "semver": "^7.3.5",
     "strip-ansi": "^6.0.0",
     "ts-node": "^10.2.1",