eslint-plugin-jest 29.7.0 → 29.9.0

package/README.md

@@ -394,11 +394,12 @@ Manually fixable by
 
 ### Requires Type Checking
 
-| 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 |     |     |     |     |
+| 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-unnecessary-assertion.md

@@ -10,9 +10,9 @@ 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.
+This rule warns when you do an assertion about being `null`, `undefined`, or
+`NaN` 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:
 
@@ -22,6 +22,8 @@ expect('hello world'.match('sunshine') ?? []).toBeNull();
 expect(User.findOrThrow(1)).toBeDefined();
 
 expect(map.getOrInsert('key', 'default')).not.toBeUndefined();
+
+expect(user.name).not.toBeNaN();
 ```
 
 The following patterns are not considered warnings:
@@ -32,4 +34,6 @@ expect('hello world'.match('sunshine')).toBeNull();
 expect(User.findOrNull(1)).toBeDefined();
 
 expect(map.get('key')).not.toBeUndefined();
+
+expect(user.age).not.toBeNaN();
 ```

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

@@ -6,70 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 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: {
@@ -86,12 +22,6 @@ var _default = exports.default = (0, _utils2.createRule)({
   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);
@@ -99,7 +29,7 @@ var _default = exports.default = (0, _utils2.createRule)({
           return;
         }
         const [argument] = jestFnCall.head.node.parent.arguments;
-        if (isBuiltinSymbolLike(services.program, services.getTypeAtLocation(argument), 'Error')) {
+        if ((0, _utils2.isBuiltinSymbolLike)(services.program, services.getTypeAtLocation(argument), 'Error')) {
           context.report({
             messageId: 'equalError',
             node

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

@@ -58,7 +58,7 @@ var _default = exports.default = (0, _utils2.createRule)({
           return;
         }
         const matcherName = (0, _utils2.getAccessorValue)(jestFnCall.matcher);
-        if (!['toBeNull', 'toBeDefined', 'toBeUndefined'].includes(matcherName)) {
+        if (!['toBeNull', 'toBeDefined', 'toBeUndefined', 'toBeNaN'].includes(matcherName)) {
           return;
         }
 
@@ -67,12 +67,12 @@ var _default = exports.default = (0, _utils2.createRule)({
           return;
         }
         const [argument] = jestFnCall.head.node.parent.arguments;
-        const isNullable = canBe(services.getTypeAtLocation(argument), matcherName === 'toBeNull' ? TypeFlags.Null : TypeFlags.Undefined);
-        if (!isNullable) {
+        const isTypePossible = canBe(services.getTypeAtLocation(argument), matcherName === 'toBeNaN' ? TypeFlags.NumberLike : matcherName === 'toBeNull' ? TypeFlags.Null : TypeFlags.Undefined);
+        if (!isTypePossible) {
           context.report({
             messageId: 'unnecessaryAssertion',
             data: {
-              thing: matcherName === 'toBeNull' ? 'null' : 'undefined'
+              thing: matcherName === 'toBeNaN' ? 'a number' : matcherName === 'toBeNull' ? 'null' : 'undefined'
             },
             node
           });

package/lib/rules/utils/index.js

@@ -57,4 +57,15 @@ Object.keys(_parseJestFnCall).forEach(function (key) {
       return _parseJestFnCall[key];
     }
   });
+});
+var _ts = require("./ts");
+Object.keys(_ts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ts[key];
+    }
+  });
 });

package/lib/rules/utils/ts.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBuiltinSymbolLike = isBuiltinSymbolLike;
+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) {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  ({
+    TypeFlags,
+    SymbolFlags
+  } = require('typescript'));
+  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();
+  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;
+}

package/lib/rules/valid-expect-with-promise.js

@@ -0,0 +1,54 @@
+"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: '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);
+    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 = (0, _utils2.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.7.0",
+  "version": "29.9.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",