eslint-plugin-jest 29.4.1 → 29.5.0

package/README.md

@@ -351,6 +351,7 @@ Manually fixable by
 | [no-standalone-expect](docs/rules/no-standalone-expect.md)                           | Disallow using `expect` outside of `it` or `test` blocks                  | ✅  |     |     |     |
 | [no-test-prefixes](docs/rules/no-test-prefixes.md)                                   | Require using `.only` and `.skip` over `f` and `x`                        | ✅  |     | 🔧  |     |
 | [no-test-return-statement](docs/rules/no-test-return-statement.md)                   | Disallow explicitly returning from tests                                  |     |     |     |     |
+| [no-unneeded-async-expect-function](docs/rules/no-unneeded-async-expect-function.md) | Disallow unnecessary async function wrapper for expected promises         |     |     | 🔧  |     |
 | [no-untyped-mock-factory](docs/rules/no-untyped-mock-factory.md)                     | Disallow using `jest.mock()` factories without an explicit type parameter |     |     | 🔧  |     |
 | [padding-around-after-all-blocks](docs/rules/padding-around-after-all-blocks.md)     | Enforce padding around `afterAll` blocks                                  |     |     | 🔧  |     |
 | [padding-around-after-each-blocks](docs/rules/padding-around-after-each-blocks.md)   | Enforce padding around `afterEach` blocks                                 |     |     | 🔧  |     |

package/docs/rules/no-unneeded-async-expect-function.md

@@ -0,0 +1,39 @@
+# Disallow unnecessary async function wrapper for expected promises (`no-unneeded-async-expect-function`)
+
+🔧 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 -->
+
+`Jest` can handle fulfilled/rejected promisified function call normally but
+occassionally, engineers wrap said function in another `async` function that is
+excessively verbose and make the tests harder to read.
+
+## Rule details
+
+This rule triggers a warning if `expect` is passed with an an `async` function
+that has a single `await` call.
+
+Examples of **incorrect** code for this rule
+
+```js
+it('wrong1', async () => {
+  await expect(async () => {
+    await doSomethingAsync();
+  }).rejects.toThrow();
+});
+
+it('wrong2', async () => {
+  await expect(async function () {
+    await doSomethingAsync();
+  }).rejects.toThrow();
+});
+```
+
+Examples of **correct** code for this rule
+
+```js
+it('right1', async () => {
+  await expect(doSomethingAsync()).rejects.toThrow();
+});
+```

package/lib/rules/no-unneeded-async-expect-function.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary async function wrapper for expected promises'
+    },
+    fixable: 'code',
+    messages: {
+      noAsyncWrapperForExpectedPromise: 'Unnecessary async function wrapper'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+        const {
+          parent
+        } = jestFnCall.head.node;
+        if (parent?.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        const [awaitNode] = parent.arguments;
+        if (!awaitNode || !(0, _utils2.isFunction)(awaitNode) || !awaitNode?.async || awaitNode.body.type !== _utils.AST_NODE_TYPES.BlockStatement || awaitNode.body.body.length !== 1) {
+          return;
+        }
+        const [callback] = awaitNode.body.body;
+        if (callback.type === _utils.AST_NODE_TYPES.ExpressionStatement && callback.expression.type === _utils.AST_NODE_TYPES.AwaitExpression && callback.expression.argument.type === _utils.AST_NODE_TYPES.CallExpression) {
+          const innerAsyncFuncCall = callback.expression.argument;
+          context.report({
+            node: awaitNode,
+            messageId: 'noAsyncWrapperForExpectedPromise',
+            fix(fixer) {
+              const {
+                sourceCode
+              } = context;
+              return [fixer.replaceTextRange([awaitNode.range[0], awaitNode.range[1]], sourceCode.getText(innerAsyncFuncCall))];
+            }
+          });
+        }
+      }
+    };
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "29.4.1",
+  "version": "29.5.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",