eslint-plugin-jest 28.0.0 → 28.1.0

package/README.md

@@ -328,6 +328,7 @@ set to warn in.\
 | [prefer-expect-resolves](docs/rules/prefer-expect-resolves.md)               | Prefer `await expect(...).resolves` over `expect(await ...)` syntax       |     |     | 🔧  |     |
 | [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                                 |     |     |     |     |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                                |     |     |     |     |
+| [prefer-importing-jest-globals](docs/rules/prefer-importing-jest-globals.md) | Prefer importing Jest globals                                             |     |     | 🔧  |     |
 | [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                              |     |     | 🔧  |     |
 | [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md) | Prefer mock resolved/rejected shorthands for promises                     |     |     | 🔧  |     |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                           |     |     |     |     |

package/docs/rules/prefer-importing-jest-globals.md

@@ -0,0 +1,47 @@
+# Prefer importing Jest globals (`prefer-importing-jest-globals`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+This rule aims to enforce explicit imports from `@jest/globals`.
+
+1. This is useful for ensuring that the Jest APIs are imported the same way in
+   the codebase.
+2. When you can't modify Jest's
+   [`injectGlobals`](https://jestjs.io/docs/configuration#injectglobals-boolean)
+   configuration property, this rule can help to ensure that the Jest globals
+   are imported explicitly and facilitate a migration to `@jest/globals`.
+
+## Rule details
+
+Examples of **incorrect** code for this rule
+
+```js
+/* eslint jest/prefer-importing-jest-globals: "error" */
+
+describe('foo', () => {
+  it('accepts this input', () => {
+    // ...
+  });
+});
+```
+
+Examples of **correct** code for this rule
+
+```js
+/* eslint jest/prefer-importing-jest-globals: "error" */
+
+import { describe, it } from '@jest/globals';
+
+describe('foo', () => {
+  it('accepts this input', () => {
+    // ...
+  });
+});
+```
+
+## Further Reading
+
+- [Documentation](https://jestjs.io/docs/api)

package/lib/rules/prefer-importing-jest-globals.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("./utils");
+const createFixerImports = (isModule, functionsToImport) => {
+  const allImportsFormatted = Array.from(functionsToImport).sort().join(', ');
+  return isModule ? `import { ${allImportsFormatted} } from '@jest/globals';` : `const { ${allImportsFormatted} } = require('@jest/globals');`;
+};
+var _default = exports.default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prefer importing Jest globals'
+    },
+    messages: {
+      preferImportingJestGlobal: `Import the following Jest functions from '@jest/globals': {{ jestFunctions }}`
+    },
+    fixable: 'code',
+    type: 'problem',
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const importedFunctionsWithSource = {};
+    const functionsToImport = new Set();
+    let reportingNode;
+    return {
+      ImportDeclaration(node) {
+        node.specifiers.forEach(specifier => {
+          if (specifier.type === 'ImportSpecifier') {
+            importedFunctionsWithSource[specifier.local.name] = node.source.value;
+          }
+        });
+      },
+      CallExpression(node) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+        if (!jestFnCall) {
+          return;
+        }
+        if (jestFnCall.head.type !== 'import') {
+          functionsToImport.add(jestFnCall.name);
+          reportingNode ||= jestFnCall.head.node;
+        }
+      },
+      'Program:exit'() {
+        // this means we found at least one function to import
+        if (!reportingNode) {
+          return;
+        }
+        const isModule = context.parserOptions.sourceType === 'module';
+        context.report({
+          node: reportingNode,
+          messageId: 'preferImportingJestGlobal',
+          data: {
+            jestFunctions: Array.from(functionsToImport).join(', ')
+          },
+          fix(fixer) {
+            const sourceCode = (0, _utils2.getSourceCode)(context);
+            const [firstNode] = sourceCode.ast.body;
+
+            // check if "use strict" directive exists
+            if (firstNode.type === _utils.AST_NODE_TYPES.ExpressionStatement && (0, _utils2.isStringNode)(firstNode.expression, 'use strict')) {
+              return fixer.insertTextAfter(firstNode, `\n${createFixerImports(isModule, functionsToImport)}`);
+            }
+            const importNode = sourceCode.ast.body.find(node => node.type === _utils.AST_NODE_TYPES.ImportDeclaration && node.source.value === '@jest/globals');
+            if (importNode?.type === _utils.AST_NODE_TYPES.ImportDeclaration) {
+              for (const specifier of importNode.specifiers) {
+                if (specifier.type === _utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported?.name) {
+                  functionsToImport.add(specifier.imported.name);
+                }
+                if (specifier.type === _utils.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                  functionsToImport.add(specifier.local.name);
+                }
+              }
+              return fixer.replaceText(importNode, createFixerImports(isModule, functionsToImport));
+            }
+            const requireNode = sourceCode.ast.body.find(node => node.type === _utils.AST_NODE_TYPES.VariableDeclaration && node.declarations.some(declaration => declaration.init?.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isIdentifier)(declaration.init.callee, 'require') && (0, _utils2.isStringNode)(declaration.init.arguments[0], '@jest/globals') && (declaration.id.type === _utils.AST_NODE_TYPES.Identifier || declaration.id.type === _utils.AST_NODE_TYPES.ObjectPattern)));
+            if (requireNode?.type !== _utils.AST_NODE_TYPES.VariableDeclaration) {
+              return fixer.insertTextBefore(reportingNode, `${createFixerImports(isModule, functionsToImport)}\n`);
+            }
+            if (requireNode.declarations[0]?.id.type === _utils.AST_NODE_TYPES.ObjectPattern) {
+              for (const property of requireNode.declarations[0].id.properties) {
+                if (property.type === _utils.AST_NODE_TYPES.Property && (0, _utils2.isSupportedAccessor)(property.key)) {
+                  functionsToImport.add((0, _utils2.getAccessorValue)(property.key));
+                }
+              }
+            }
+            return fixer.replaceText(requireNode, `${createFixerImports(isModule, functionsToImport)}`);
+          }
+        });
+      }
+    };
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "28.0.0",
+  "version": "28.1.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -130,8 +130,5 @@
   },
   "publishConfig": {
     "provenance": true
-  },
-  "resolutions": {
-    "@typescript-eslint/typescript-estree@5.62.0": "patch:@typescript-eslint/typescript-estree@npm:^5.62.0#./.yarn/patches/@typescript-eslint-typescript-estree-npm-5.62.0-5d1ea132a9.patch"
   }
 }