eslint-plugin-jest 27.0.4 → 27.1.1

package/README.md

@@ -220,6 +220,7 @@ installations requiring long-term consistency.
 | [no-jasmine-globals](docs/rules/no-jasmine-globals.md)                       | Disallow Jasmine globals                                            | ![recommended][] | ![fixable][] |
 | [no-large-snapshots](docs/rules/no-large-snapshots.md)                       | disallow large snapshots                                            |                  |              |
 | [no-mocks-import](docs/rules/no-mocks-import.md)                             | Disallow manually importing from `__mocks__`                        | ![recommended][] |              |
+| [no-restricted-jest-methods](docs/rules/no-restricted-jest-methods.md)       | Disallow specific `jest.` methods                                   |                  |              |
 | [no-restricted-matchers](docs/rules/no-restricted-matchers.md)               | Disallow specific matchers & modifiers                              |                  |              |
 | [no-standalone-expect](docs/rules/no-standalone-expect.md)                   | Disallow using `expect` outside of `it` or `test` blocks            | ![recommended][] |              |
 | [no-test-prefixes](docs/rules/no-test-prefixes.md)                           | Use `.only` and `.skip` over `f` and `x`                            | ![recommended][] | ![fixable][] |

package/docs/rules/no-restricted-jest-methods.md

@@ -0,0 +1,55 @@
+# Disallow specific `jest.` methods (`no-restricted-jest-methods`)
+
+💼 This rule is enabled in the following
+[configs](https://github.com/jest-community/eslint-plugin-jest/blob/main/README.md#shareable-configurations):
+`all`.
+
+<!-- end rule header -->
+
+You may wish to restrict the use of specific `jest` methods.
+
+## Rule details
+
+This rule checks for the usage of specific methods on the `jest` object, which
+can be used to disallow certain patterns such as spies and mocks.
+
+## Options
+
+Restrictions are expressed in the form of a map, with the value being either a
+string message to be shown, or `null` if a generic default message should be
+used.
+
+By default, this map is empty, meaning no `jest` methods are banned.
+
+For example:
+
+```json
+{
+  "jest/no-restricted-jest-methods": [
+    "error",
+    {
+      "advanceTimersByTime": null,
+      "spyOn": "Don't use spies"
+    }
+  ]
+}
+```
+
+Examples of **incorrect** code for this rule with the above configuration
+
+```js
+jest.useFakeTimers();
+it('calls the callback after 1 second via advanceTimersByTime', () => {
+  // ...
+
+  jest.advanceTimersByTime(1000);
+
+  // ...
+});
+
+test('plays video', () => {
+  const spy = jest.spyOn(video, 'play');
+
+  // ...
+});
+```

package/docs/rules/prefer-expect-resolves.md

@@ -58,6 +58,8 @@ it('is true', async () => {
 });
 
 it('errors', async () => {
-  await expect(Promise.rejects('oh noes!')).rejects.toThrow('oh noes!');
+  await expect(Promise.reject(new Error('oh noes!'))).rejects.toThrowError(
+    'oh noes!',
+  );
 });
 ```

package/lib/rules/no-restricted-jest-methods.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+const messages = {
+  restrictedJestMethod: 'Use of `{{ restriction }}` is disallowed',
+  restrictedJestMethodWithMessage: '{{ message }}'
+};
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Disallow specific `jest.` methods',
+      recommended: false
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        type: ['string', 'null']
+      }
+    }],
+    messages
+  },
+  defaultOptions: [{}],
+
+  create(context, [restrictedMethods]) {
+    return {
+      CallExpression(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'jest') {
+          return;
+        }
+
+        const method = (0, _utils.getAccessorValue)(jestFnCall.members[0]);
+
+        if (method in restrictedMethods) {
+          const message = restrictedMethods[method];
+          context.report({
+            messageId: message ? 'restrictedJestMethodWithMessage' : 'restrictedJestMethod',
+            data: {
+              message,
+              restriction: method
+            },
+            loc: {
+              start: jestFnCall.members[0].loc.start,
+              end: jestFnCall.members[jestFnCall.members.length - 1].loc.end
+            }
+          });
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-to-be.js

@@ -21,7 +21,11 @@ const isNullEqualityMatcher = expectFnCall => isNullLiteral((0, _utils2.getFirst
 const isFirstArgumentIdentifier = (expectFnCall, name) => (0, _utils2.isIdentifier)((0, _utils2.getFirstMatcherArg)(expectFnCall), name);
 
 const shouldUseToBe = expectFnCall => {
-  const firstArg = (0, _utils2.getFirstMatcherArg)(expectFnCall);
+  let firstArg = (0, _utils2.getFirstMatcherArg)(expectFnCall);
+
+  if (firstArg.type === _utils.AST_NODE_TYPES.UnaryExpression && firstArg.operator === '-') {
+    firstArg = firstArg.argument;
+  }
 
   if (firstArg.type === _utils.AST_NODE_TYPES.Literal) {
     // regex literals are classed as literals, but they're actually objects

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "27.0.4",
+  "version": "27.1.1",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -110,6 +110,7 @@
     "@semantic-release/git": "^10.0.0",
     "@tsconfig/node14": "^1.0.3",
     "@types/dedent": "^0.7.0",
+    "@types/eslint": "^8.4.6",
     "@types/jest": "^29.0.0",
     "@types/node": "^14.18.26",
     "@types/prettier": "^2.0.0",