eslint-plugin-jest 29.6.0 → 29.7.0

package/README.md

@@ -396,6 +396,7 @@ Manually fixable by
 
 | Name                                                               | Description                                                  | 💼  | ⚠️  | 🔧  | 💡  |
 | :----------------------------------------------------------------- | :----------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [no-error-equal](docs/rules/no-error-equal.md)                     | Disallow using equality matchers on error types              |     |     |     |     |
 | [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 |     |     |     |     |
 

package/docs/rules/no-error-equal.md

@@ -0,0 +1,35 @@
+# Disallow using equality matchers on error types (`no-error-equal`)
+
+💭 This rule requires
+[type information](https://typescript-eslint.io/linting/typed-linting).
+
+<!-- end auto-generated rule header -->
+
+When comparing errors, `toEqual` and `toStrictEqual` will only compare the
+`message` properties, meaning tests can pass even if the errors are of different
+types.
+
+Instead, it is better to use `toThrow` which does check the error type along
+with its message.
+
+## Rule details
+
+This rule warns when `toEqual` and `toStrictEqual` is used with an `Error` type.
+
+The following patterns are considered warnings:
+
+```ts
+expect(new AggregateError([], expect.any(String))).toEqual(
+  new Error(expect.any(String)),
+);
+
+expect(new Error('hello world')).toStrictEqual('hello sunshine');
+```
+
+The following patterns are not considered warnings:
+
+```ts
+expect(() => throw new AggregateError([], expect.any(String))).toThrow(new Error(expect.any(String)));
+
+expect(() => throw new Error('hello world')).toThrow('hello sunshine');
+```

package/lib/rules/no-error-equal.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+let SymbolFlags;
+let TypeFlags;
+function isSymbolFromDefaultLibrary(program, symbol) {
+  /* istanbul ignore next */
+  const declarations = symbol.getDeclarations() ?? [];
+  for (const declaration of declarations) {
+    const sourceFile = declaration.getSourceFile();
+
+    /* istanbul ignore else */
+    if (program.isSourceFileDefaultLibrary(sourceFile)) {
+      return true;
+    }
+  }
+
+  /* istanbul ignore next */
+  return false;
+}
+function isBuiltinSymbolLike(program, type, symbolName) {
+  return isBuiltinSymbolLikeRecurser(program, type, subType => {
+    const symbol = subType.getSymbol();
+    if (!symbol) {
+      return false;
+    }
+    const actualSymbolName = symbol.getName();
+    if (actualSymbolName === symbolName && isSymbolFromDefaultLibrary(program, symbol)) {
+      return true;
+    }
+    return null;
+  });
+}
+function isBuiltinSymbolLikeRecurser(program, type, predicate) {
+  if (type.isIntersection()) {
+    return type.types.some(t => isBuiltinSymbolLikeRecurser(program, t, predicate));
+  }
+  if (type.isUnion()) {
+    return type.types.every(t => isBuiltinSymbolLikeRecurser(program, t, predicate));
+  }
+  if (isTypeParameter(type)) {
+    const t = type.getConstraint();
+    if (t) {
+      return isBuiltinSymbolLikeRecurser(program, t, predicate);
+    }
+    return false;
+  }
+  const predicateResult = predicate(type);
+  if (typeof predicateResult === 'boolean') {
+    return predicateResult;
+  }
+  const symbol = type.getSymbol();
+
+  /* istanbul ignore next */
+  if (symbol && symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+    const checker = program.getTypeChecker();
+    for (const baseType of checker.getBaseTypes(type)) {
+      if (isBuiltinSymbolLikeRecurser(program, baseType, predicate)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isTypeParameter(type) {
+  return (type.flags & TypeFlags.TypeParameter) !== 0;
+}
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Disallow using equality matchers on error types',
+      requiresTypeChecking: true
+    },
+    messages: {
+      equalError: 'Avoid using equality matchers to check errors'
+    },
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = _utils.ESLintUtils.getParserServices(context);
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    ({
+      TypeFlags,
+      SymbolFlags
+    } = 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 || !['toEqual', 'toStrictEqual'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher))) {
+          return;
+        }
+        const [argument] = jestFnCall.head.node.parent.arguments;
+        if (isBuiltinSymbolLike(services.program, services.getTypeAtLocation(argument), 'Error')) {
+          context.report({
+            messageId: 'equalError',
+            node
+          });
+        }
+      }
+    };
+  }
+});

package/lib/rules/no-unnecessary-assertion.js

@@ -61,6 +61,11 @@ var _default = exports.default = (0, _utils2.createRule)({
         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) {

package/package.json

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