eslint-plugin-jest 29.6.1 → 29.8.0

package/README.md

@@ -394,10 +394,12 @@ Manually fixable by
 
 ### Requires Type Checking
 
-| 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 |     |     |     |     |
+| 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                                |     |     |     |     |
+| [valid-expect-with-promise](docs/rules/valid-expect-with-promise.md) | Require that `resolve` and `reject` modifiers are present (and only) for promise-like types |     |     |     |     |
 
 <!-- end auto-generated rules list -->
 

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/docs/rules/valid-expect-with-promise.md

@@ -0,0 +1,40 @@
+# Require that `resolve` and `reject` modifiers are present (and only) for promise-like types (`valid-expect-with-promise`)
+
+💭 This rule requires
+[type information](https://typescript-eslint.io/linting/typed-linting).
+
+<!-- end auto-generated rule header -->
+
+When working with promises, you must remember to use `resolves` and `rejects` to
+assert on the value returned (or thrown) by the promise, rather than the promise
+itself.
+
+Inversely, while Jest does not prevent you from using `resolves` and `rejects`
+on non-promise values, it is not necessary.
+
+When TypeScript is in use, it is possible to determine when `resolves` and
+`rejects` should and should not be needed.
+
+## Rule details
+
+This rule warns when:
+
+- an `expect` is given a promise-like value but without `resolves` or `rejects`
+- an `expect` is not given a promise-like value, but is used with `resolves` or
+  `rejects`
+
+The following patterns are considered warnings:
+
+```ts
+expect('hello world').resolves.toBe('hello sunshine');
+
+expect(new Promise(r => r(0))).toThrow('oh noes!');
+```
+
+The following patterns are not considered warnings:
+
+```ts
+expect('hello world').toBe('hello sunshine');
+
+expect(new Promise(r => r(0))).rejects.toThrow('oh noes!');
+```

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/valid-expect-with-promise.js

@@ -0,0 +1,124 @@
+"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: 'Require that `resolve` and `reject` modifiers are present (and only) for promise-like types',
+      requiresTypeChecking: true
+    },
+    messages: {
+      poorlyExpectedPromise: 'Subject is a promise so resolve or reject should be used',
+      unneededRejectResolve: 'Subject is not a promise so {{ modifier }} is not needed'
+    },
+    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) {
+          return;
+        }
+        const [argument] = jestFnCall.head.node.parent.arguments;
+        const isPromiseLike = isBuiltinSymbolLike(services.program, services.getTypeAtLocation(argument), 'Promise');
+        const promiseModifier = jestFnCall.modifiers.find(nod => (0, _utils2.getAccessorValue)(nod) !== 'not');
+        if (isPromiseLike && !promiseModifier) {
+          context.report({
+            messageId: 'poorlyExpectedPromise',
+            node
+          });
+          return;
+        }
+        if (!isPromiseLike && promiseModifier) {
+          context.report({
+            messageId: 'unneededRejectResolve',
+            data: {
+              modifier: (0, _utils2.getAccessorValue)(promiseModifier)
+            },
+            node: promiseModifier
+          });
+        }
+      }
+    };
+  }
+});

package/package.json

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