eslint-plugin-jest 29.4.1 → 29.6.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                                 |     |     | 🔧  |     |
@@ -393,9 +394,10 @@ Manually fixable by
 
 ### Requires Type Checking
 
-| Name                                           | Description                                                  | 💼  | ⚠️  | 🔧  | 💡  |
-| :--------------------------------------------- | :----------------------------------------------------------- | :-- | :-- | :-- | :-- |
-| [unbound-method](docs/rules/unbound-method.md) | Enforce unbound methods are called with their expected scope |     |     |     |     |
+| Name                                                               | Description                                                  | 💼  | ⚠️  | 🔧  | 💡  |
+| :----------------------------------------------------------------- | :----------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [no-unnecessary-assertion](docs/rules/no-unnecessary-assertion.md) | Disallow unnecessary assertions based on types               |     |     |     |     |
+| [unbound-method](docs/rules/unbound-method.md)                     | Enforce unbound methods are called with their expected scope |     |     |     |     |
 
 <!-- end auto-generated rules list -->
 

package/docs/rules/no-unnecessary-assertion.md

@@ -0,0 +1,35 @@
+# Disallow unnecessary assertions based on types (`no-unnecessary-assertion`)
+
+💭 This rule requires
+[type information](https://typescript-eslint.io/linting/typed-linting).
+
+<!-- end auto-generated rule header -->
+
+When using TypeScript, runtime assertions based on types can often be omitted
+provided that the types are accurate.
+
+## Rule details
+
+This rule warns when you do an assertion about being `null` or `undefined` on
+something that cannot be those types, as that indicates either the assertion can
+be removed or the types need to be adjusted.
+
+The following patterns are considered warnings:
+
+```ts
+expect('hello world'.match('sunshine') ?? []).toBeNull();
+
+expect(User.findOrThrow(1)).toBeDefined();
+
+expect(map.getOrInsert('key', 'default')).not.toBeUndefined();
+```
+
+The following patterns are not considered warnings:
+
+```ts
+expect('hello world'.match('sunshine')).toBeNull();
+
+expect(User.findOrNull(1)).toBeDefined();
+
+expect(map.get('key')).not.toBeUndefined();
+```

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-unnecessary-assertion.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const canBe = (firstArgumentType, flag) => {
+  if (firstArgumentType.isUnion()) {
+    return firstArgumentType.types.some(typ => typ.flags & flag);
+  }
+  return firstArgumentType.flags & flag;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow unnecessary assertions based on types',
+      requiresTypeChecking: true
+    },
+    messages: {
+      unnecessaryAssertion: 'Unnecessary assertion, subject cannot be {{ thing }}',
+      noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = _utils.ESLintUtils.getParserServices(context);
+    const compilerOptions = services.program.getCompilerOptions();
+    const isStrictNullChecks = compilerOptions.strictNullChecks || compilerOptions.strict && compilerOptions.strictNullChecks !== false;
+    if (!isStrictNullChecks) {
+      context.report({
+        loc: {
+          start: {
+            column: 0,
+            line: 0
+          },
+          end: {
+            column: 0,
+            line: 0
+          }
+        },
+        messageId: 'noStrictNullCheck'
+      });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const {
+      TypeFlags
+    } = require('typescript');
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (jestFnCall?.type !== 'expect' || jestFnCall.head.node.parent.type !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+        const matcherName = (0, _utils2.getAccessorValue)(jestFnCall.matcher);
+        if (!['toBeNull', 'toBeDefined', 'toBeUndefined'].includes(matcherName)) {
+          return;
+        }
+        const [argument] = jestFnCall.head.node.parent.arguments;
+        const isNullable = canBe(services.getTypeAtLocation(argument), matcherName === 'toBeNull' ? TypeFlags.Null : TypeFlags.Undefined);
+        if (!isNullable) {
+          context.report({
+            messageId: 'unnecessaryAssertion',
+            data: {
+              thing: matcherName === 'toBeNull' ? 'null' : 'undefined'
+            },
+            node
+          });
+        }
+      }
+    };
+  }
+});

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.6.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",