feat(rule): disallow unnecessary async function wrapper for single await call

docs/rules/no-async-wrapper-for-expected-promise.md

@@ -0,0 +1,39 @@
+# Disallow unnecessary async function wrapper for expected promises (`no-async-wrapper-for-expected-promise`)
+
+🔧 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 a single `await` function call is wrapped by an
+unnecessary `async` function.
+
+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();
+});
+```

src/__tests__/__snapshots__/rules.test.ts.snap

@@ -15,6 +15,7 @@ exports[`rules should export configs that refer to actual rules 1`] = `
       "jest/max-expects": "error",
       "jest/max-nested-describe": "error",
       "jest/no-alias-methods": "error",
+      "jest/no-async-wrapper-for-expected-promise": "error",
       "jest/no-commented-out-tests": "error",
       "jest/no-conditional-expect": "error",
       "jest/no-conditional-in-test": "error",
@@ -108,6 +109,7 @@ exports[`rules should export configs that refer to actual rules 1`] = `
       "jest/max-expects": "error",
       "jest/max-nested-describe": "error",
       "jest/no-alias-methods": "error",
+      "jest/no-async-wrapper-for-expected-promise": "error",
       "jest/no-commented-out-tests": "error",
       "jest/no-conditional-expect": "error",
       "jest/no-conditional-in-test": "error",

src/__tests__/rules.test.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'fs';
 import { resolve } from 'path';
 import plugin from '../';
 
-const numberOfRules = 64;
+const numberOfRules = 65;
 const ruleNames = Object.keys(plugin.rules);
 const deprecatedRules = Object.entries(plugin.rules)
   .filter(([, rule]) => rule.meta.deprecated)

src/rules/__tests__/no-async-wrapper-for-expected-promise.test.ts

@@ -0,0 +1,141 @@
+import dedent from 'dedent';
+import rule from '../no-async-wrapper-for-expected-promise';
+import { FlatCompatRuleTester as RuleTester, espreeParser } from './test-utils';
+
+const ruleTester = new RuleTester({
+  parser: espreeParser,
+  parserOptions: {
+    ecmaVersion: 2017,
+  },
+});
+
+ruleTester.run('no-async-wrapper-for-expected-promise', rule, {
+  valid: [
+    'expect.hasAssertions()',
+    dedent`
+        it('pass', async () => {
+            expect();
+        })
+        `,
+    dedent`
+        it('pass', async () => {
+            await expect(doSomethingAsync()).rejects.toThrow();
+        })
+        `,
+    dedent`
+        it('pass', async () => {
+            await expect(doSomethingAsync(1, 2)).resolves.toBe(1);
+        })
+        `,
+    dedent`
+        it('pass', async () => {
+            await expect(async () => {
+                await doSomethingAsync();
+                await doSomethingTwiceAsync(1, 2);
+            }).rejects.toThrow();
+        })
+        `,
+    {
+      code: dedent`
+        import { expect as pleaseExpect } from '@jest/globals';
+        it('pass', async () => {
+            await pleaseExpect(doSomethingAsync()).rejects.toThrow();
+        })
+        `,
+      parserOptions: { sourceType: 'module' },
+    },
+    dedent`
+        it('pass', async () => {
+            await expect(async () => {
+                doSomethingSync();
+            }).rejects.toThrow();
+        })
+    `,
+  ],
+  invalid: [
+    {
+      code: dedent`
+        it('should be fix', async () => {
+            await expect(async () => {
+                await doSomethingAsync();
+            }).rejects.toThrow(); 
+        })
+    `,
+      output: dedent`
+        it('should be fix', async () => {
+            await expect(doSomethingAsync()).rejects.toThrow(); 
+        })
+    `,
+      errors: [
+        {
+          endColumn: 6,
+          column: 18,
+          messageId: 'noAsyncWrapperForExpectedPromise',
+        },
+      ],
+    },
+    {
+      code: dedent`
+        it('should be fix', async () => {
+            await expect(async function () {
+                await doSomethingAsync();
+            }).rejects.toThrow(); 
+        })
+    `,
+      output: dedent`
+        it('should be fix', async () => {
+            await expect(doSomethingAsync()).rejects.toThrow(); 
+        })
+    `,
+      errors: [
+        {
+          endColumn: 6,
+          column: 18,
+          messageId: 'noAsyncWrapperForExpectedPromise',
+        },
+      ],
+    },
+    {
+      code: dedent`
+        it('should be fix', async () => {
+            await expect(async () => {
+                await doSomethingAsync(1, 2);
+            }).rejects.toThrow(); 
+        })
+    `,
+      output: dedent`
+        it('should be fix', async () => {
+            await expect(doSomethingAsync(1, 2)).rejects.toThrow(); 
+        })
+    `,
+      errors: [
+        {
+          endColumn: 6,
+          column: 18,
+          messageId: 'noAsyncWrapperForExpectedPromise',
+        },
+      ],
+    },
+    {
+      code: dedent`
+        it('should be fix', async () => {
+            await expect(async function () {
+                await doSomethingAsync(1, 2);
+            }).rejects.toThrow(); 
+        })
+    `,
+      output: dedent`
+        it('should be fix', async () => {
+            await expect(doSomethingAsync(1, 2)).rejects.toThrow(); 
+        })
+    `,
+      errors: [
+        {
+          endColumn: 6,
+          column: 18,
+          messageId: 'noAsyncWrapperForExpectedPromise',
+        },
+      ],
+    },
+  ],
+});

src/rules/no-async-wrapper-for-expected-promise.ts

@@ -0,0 +1,74 @@
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import { createRule, parseJestFnCall } from './utils';
+
+export default createRule({
+  name: __filename,
+  meta: {
+    docs: {
+      description:
+        'Disallow unnecessary async function wrapper for expected promises',
+    },
+    fixable: 'code',
+    messages: {
+      noAsyncWrapperForExpectedPromise:
+        'Rejected/resolved promises should not be wrapped in async function',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node: TSESTree.CallExpression) {
+        const jestFnCall = parseJestFnCall(node, context);
+
+        if (jestFnCall?.type !== 'expect') {
+          return;
+        }
+
+        const { parent } = jestFnCall.head.node;
+
+        if (parent?.type !== AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        const [awaitNode] = parent.arguments;
+
+        if (
+          (awaitNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            awaitNode?.type !== AST_NODE_TYPES.FunctionExpression) ||
+          !awaitNode?.async ||
+          awaitNode.body.type !== AST_NODE_TYPES.BlockStatement ||
+          awaitNode.body.body.length !== 1
+        ) {
+          return;
+        }
+
+        const [callback] = awaitNode.body.body;
+
+        if (
+          callback.type === AST_NODE_TYPES.ExpressionStatement &&
+          callback.expression.type === AST_NODE_TYPES.AwaitExpression &&
+          callback.expression.argument.type === 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),
+                ),
+              ];
+            },
+          });
+        }
+      },
+    };
+  },
+});