eslint-plugin-jest 29.5.0 → 29.6.1

package/README.md

@@ -394,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/lib/rules/no-unnecessary-assertion.js

@@ -0,0 +1,83 @@
+"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;
+        }
+
+        // todo: we should support resolving promise types
+        if (jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) !== 'not')) {
+          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/package.json

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