eslint-plugin-jest 26.1.1 → 26.5.3

package/README.md

@@ -59,6 +59,53 @@ doing:
 This is included in all configs shared by this plugin, so can be omitted if
 extending them.
 
+#### Aliased Jest globals
+
+You can tell this plugin about any global Jests you have aliased using the
+`globalAliases` setting:
+
+```json
+{
+  "settings": {
+    "jest": {
+      "globalAliases": {
+        "describe": ["context"],
+        "fdescribe": ["fcontext"],
+        "xdescribe": ["xcontext"]
+      }
+    }
+  }
+}
+```
+
+### Running rules only on test-related files
+
+The rules provided by this plugin assume that the files they are checking are
+test-related. This means it's generally not suitable to include them in your
+top-level configuration as that applies to all files being linted which can
+include source files.
+
+You can use
+[overrides](https://eslint.org/docs/user-guide/configuring/configuration-files#how-do-overrides-work)
+to have ESLint apply additional rules to specific files:
+
+```json
+{
+  "extends": ["eslint:recommended"],
+  "overrides": [
+    {
+      "files": ["test/**"],
+      "plugins": ["jest"],
+      "extends": ["plugin:jest/recommended"],
+      "rules": { "jest/prefer-expect-assertions": "off" }
+    }
+  ],
+  "rules": {
+    "indent": ["error", 2]
+  }
+}
+```
+
 ### Jest `version` setting
 
 The behaviour of some rules (specifically [`no-deprecated-functions`][]) change
@@ -181,6 +228,7 @@ installations requiring long-term consistency.
 | [prefer-equality-matcher](docs/rules/prefer-equality-matcher.md)             | Suggest using the built-in equality matchers                        |                  | ![suggest][] |
 | [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)           | Suggest using `expect.assertions()` OR `expect.hasAssertions()`     |                  | ![suggest][] |
 | [prefer-expect-resolves](docs/rules/prefer-expect-resolves.md)               | Prefer `await expect(...).resolves` over `expect(await ...)` syntax |                  | ![fixable][] |
+| [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-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                        |                  | ![fixable][] |
 | [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                     |                  |              |
@@ -211,8 +259,8 @@ adjust your eslint config as outlined
 
 Note that unlike the type-checking rules in `@typescript-eslint/eslint-plugin`,
 the rules here will fallback to doing nothing if type information is not
-available, meaning its safe to include them in shared configs that could be used
-on JavaScript and TypeScript projects.
+available, meaning it's safe to include them in shared configs that could be
+used on JavaScript and TypeScript projects.
 
 Also note that `unbound-method` depends on `@typescript-eslint/eslint-plugin`,
 as it extends the original `unbound-method` rule from that plugin.

package/docs/rules/no-conditional-expect.md

@@ -107,7 +107,7 @@ While you can use `expect.assertions` & `expect.hasAssertions` for these
 situations, they only work with `expect`.
 
 A better way to handle this situation is to introduce a wrapper to handle the
-catching, and otherwise returns a specific "no error thrown" error if nothing is
+catching, and otherwise return a specific "no error thrown" error if nothing is
 thrown by the wrapped function:
 
 ```typescript

package/docs/rules/no-deprecated-functions.md

@@ -37,8 +37,7 @@ Originally, the `requireActual` & `requireMock` the `requireActual`&
 
 These functions were later moved onto the `jest` object in order to be easier
 for type checkers to handle, and their use via `require` deprecated. Finally,
-the release of Jest 26 saw them removed from the `require` function all
-together.
+the release of Jest 26 saw them removed from the `require` function altogether.
 
 ### `jest.runTimersToTime`
 

package/docs/rules/no-identical-title.md

@@ -7,7 +7,7 @@ fix.
 
 ## Rule Details
 
-This rule looks at the title of every test and test suites. It will report when
+This rule looks at the title of every test and test suite. It will report when
 two test suites or two test cases at the same level of a test suite have the
 same title.
 

package/docs/rules/no-jasmine-globals.md

@@ -9,8 +9,8 @@ API.
 
 ### Rule details
 
-This rule reports on any usage of Jasmine globals which is not ported to Jest,
-and suggests alternative from Jest's own API.
+This rule reports on any usage of Jasmine globals, which is not ported to Jest,
+and suggests alternatives from Jest's own API.
 
 ### Default configuration
 

package/docs/rules/no-jest-import.md

@@ -17,4 +17,4 @@ first place.
 
 ## Further Reading
 
-\*[The Jest Object](https://facebook.github.io/jest/docs/en/jest-object.html)
+- [The Jest Object](https://facebook.github.io/jest/docs/en/jest-object.html)

package/docs/rules/no-large-snapshots.md

@@ -118,8 +118,8 @@ External). Use `inlineMaxSize` for
 [Inline Snapshots](https://jestjs.io/docs/en/snapshot-testing#inline-snapshots)
 size and `maxSize` for
 [External Snapshots](https://jestjs.io/docs/en/snapshot-testing#snapshot-testing-with-jest).
-If only `maxSize` is provided on options, the value of `maxSize` will be used to
-both snapshot types (Inline and External).
+If only `maxSize` is provided on options, the value of `maxSize` will be used
+for both snapshot types (Inline and External).
 
 Since `eslint-disable` comments are not preserved by Jest when updating
 snapshots, you can use the `allowedSnapshots` option to have specific snapshots

package/docs/rules/no-standalone-expect.md

@@ -61,7 +61,7 @@ describe('a test', () => {
 ```
 
 \*Note that this rule will not trigger if the helper function is never used even
-thought the `expect` will not execute. Rely on a rule like no-unused-vars for
+though the `expect` will not execute. Rely on a rule like no-unused-vars for
 this case.
 
 ### Options

package/docs/rules/prefer-comparison-matcher.md

@@ -1,6 +1,6 @@
 # Suggest using the built-in comparison matchers (`prefer-comparison-matcher`)
 
-Jest has a number of built-in matchers for comparing numbers which allow for
+Jest has a number of built-in matchers for comparing numbers, which allow for
 more readable tests and error messages if an expectation fails.
 
 ## Rule details

package/docs/rules/prefer-equality-matcher.md

@@ -1,6 +1,6 @@
 # Suggest using the built-in equality matchers (`prefer-equality-matcher`)
 
-Jest has built-in matchers for expecting equality which allow for more readable
+Jest has built-in matchers for expecting equality, which allow for more readable
 tests and error messages if an expectation fails.
 
 ## Rule details

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

@@ -215,7 +215,7 @@ describe('getNumbers', () => {
 
 describe('/users', () => {
   it.each([1, 2, 3])('returns ok', id => {
-    expect.assertions(3);
+    expect.assertions(1);
 
     client.get(`/users/${id}`, response => {
       expect(response.status).toBe(200);

package/docs/rules/prefer-hooks-in-order.md

@@ -0,0 +1,133 @@
+# Prefer having hooks in a consistent order (`prefer-hooks-in-order`)
+
+While hooks can be setup in any order, they're always called by `jest` in this
+specific order:
+
+1. `beforeAll`
+1. `beforeEach`
+1. `afterEach`
+1. `afterAll`
+
+This rule aims to make that more obvious by enforcing grouped hooks be setup in
+that order within tests.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule
+
+```js
+/* eslint jest/prefer-hooks-in-order: "error" */
+
+describe('foo', () => {
+  beforeEach(() => {
+    seedMyDatabase();
+  });
+
+  beforeAll(() => {
+    createMyDatabase();
+  });
+
+  it('accepts this input', () => {
+    // ...
+  });
+
+  it('returns that value', () => {
+    // ...
+  });
+
+  describe('when the database has specific values', () => {
+    const specificValue = '...';
+
+    beforeEach(() => {
+      seedMyDatabase(specificValue);
+    });
+
+    it('accepts that input', () => {
+      // ...
+    });
+
+    it('throws an error', () => {
+      // ...
+    });
+
+    afterEach(() => {
+      clearLogger();
+    });
+    beforeEach(() => {
+      mockLogger();
+    });
+
+    it('logs a message', () => {
+      // ...
+    });
+  });
+
+  afterAll(() => {
+    removeMyDatabase();
+  });
+});
+```
+
+Examples of **correct** code for this rule
+
+```js
+/* eslint jest/prefer-hooks-in-order: "error" */
+
+describe('foo', () => {
+  beforeAll(() => {
+    createMyDatabase();
+  });
+
+  beforeEach(() => {
+    seedMyDatabase();
+  });
+
+  it('accepts this input', () => {
+    // ...
+  });
+
+  it('returns that value', () => {
+    // ...
+  });
+
+  describe('when the database has specific values', () => {
+    const specificValue = '...';
+
+    beforeEach(() => {
+      seedMyDatabase(specificValue);
+    });
+
+    it('accepts that input', () => {
+      // ...
+    });
+
+    it('throws an error', () => {
+      // ...
+    });
+
+    beforeEach(() => {
+      mockLogger();
+    });
+
+    afterEach(() => {
+      clearLogger();
+    });
+
+    it('logs a message', () => {
+      // ...
+    });
+  });
+
+  afterAll(() => {
+    removeMyDatabase();
+  });
+});
+```
+
+## Also See
+
+- [`prefer-hooks-on-top`](prefer-hooks-on-top.md)
+
+## Further Reading
+
+- [Order of execution of describe and test blocks](https://jestjs.io/docs/setup-teardown#order-of-execution-of-describe-and-test-blocks)

package/docs/rules/prefer-hooks-on-top.md

@@ -1,7 +1,7 @@
 # Suggest having hooks before any test cases (`prefer-hooks-on-top`)
 
 While hooks can be setup anywhere in a test file, they are always called in a
-specific order which means it can be confusing if they're intermixed with test
+specific order, which means it can be confusing if they're intermixed with test
 cases.
 
 This rule helps to ensure that hooks are always defined before test cases.

package/docs/rules/prefer-lowercase-title.md

@@ -73,8 +73,8 @@ it('Uppercase description');
 
 ### `allowedPrefixes`
 
-This array option allows specifying prefixes which contain capitals that titles
-can start with. This can be useful when writing tests for api endpoints, where
+This array option allows specifying prefixes, which contain capitals that titles
+can start with. This can be useful when writing tests for API endpoints, where
 you'd like to prefix with the HTTP method.
 
 By default, nothing is allowed (the equivalent of `{ "allowedPrefixes": [] }`).

package/docs/rules/valid-expect.md

@@ -136,9 +136,9 @@ test('all the things', async () => {
   await Promise.resolve(
     expect(Promise.resolve('hello')).resolves.toEqual('hello'),
   );
-  await Promise.all(
+  await Promise.all([
     expect(Promise.resolve('hello')).resolves.toEqual('hello'),
     expect(Promise.resolve('hi')).resolves.toEqual('hi'),
-  );
+  ]);
 });
 ```

package/lib/rules/consistent-test-it.js

@@ -50,19 +50,20 @@ var _default = (0, _utils2.createRule)({
     let describeNestingLevel = 0;
     return {
       CallExpression(node) {
-        const nodeName = (0, _utils2.getNodeName)(node.callee);
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        if (!nodeName) {
+        if (!jestFnCall) {
           return;
         }
 
-        if ((0, _utils2.isDescribeCall)(node)) {
+        if (jestFnCall.type === 'describe') {
           describeNestingLevel++;
+          return;
         }
 
         const funcNode = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-        if ((0, _utils2.isTestCaseCall)(node) && describeNestingLevel === 0 && !nodeName.includes(testKeyword)) {
+        if (jestFnCall.type === 'test' && describeNestingLevel === 0 && !jestFnCall.name.endsWith(testKeyword)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeyword);
           context.report({
             messageId: 'consistentMethod',
@@ -71,11 +72,11 @@ var _default = (0, _utils2.createRule)({
               testKeyword,
               oppositeTestKeyword
             },
-            fix: buildFixer(funcNode, nodeName, testKeyword)
+            fix: buildFixer(funcNode, jestFnCall.name, testKeyword)
           });
         }
 
-        if ((0, _utils2.isTestCaseCall)(node) && describeNestingLevel > 0 && !nodeName.includes(testKeywordWithinDescribe)) {
+        if (jestFnCall.type === 'test' && describeNestingLevel > 0 && !jestFnCall.name.endsWith(testKeywordWithinDescribe)) {
           const oppositeTestKeyword = getOppositeTestKeyword(testKeywordWithinDescribe);
           context.report({
             messageId: 'consistentMethodWithinDescribe',
@@ -84,13 +85,13 @@ var _default = (0, _utils2.createRule)({
               testKeywordWithinDescribe,
               oppositeTestKeyword
             },
-            fix: buildFixer(funcNode, nodeName, testKeywordWithinDescribe)
+            fix: buildFixer(funcNode, jestFnCall.name, testKeywordWithinDescribe)
           });
         }
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils2.isDescribeCall)(node)) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['describe'])) {
           describeNestingLevel--;
         }
       }

package/lib/rules/expect-expect.js

@@ -23,8 +23,8 @@ var _utils2 = require("./utils");
  */
 function matchesAssertFunctionName(nodeName, patterns) {
   return patterns.some(p => new RegExp(`^${p.split('.').map(x => {
-    if (x === '**') return '[a-z\\.]*';
-    return x.replace(/\*/gu, '[a-z]*');
+    if (x === '**') return '[a-z\\d\\.]*';
+    return x.replace(/\*/gu, '[a-z\\d]*');
   }).join('\\.')}(\\.|$)`, 'ui').test(nodeName));
 }
 
@@ -76,7 +76,7 @@ var _default = (0, _utils2.createRule)({
 
         if (node.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
           const declaredVariables = context.getDeclaredVariables(node);
-          const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+          const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context);
           checkCallExpressionUsed(testCallExpressions);
         }
 
@@ -93,7 +93,7 @@ var _default = (0, _utils2.createRule)({
 
         const name = (_getNodeName = (0, _utils2.getNodeName)(node.callee)) !== null && _getNodeName !== void 0 ? _getNodeName : '';
 
-        if ((0, _utils2.isTestCaseCall)(node) || additionalTestBlockFunctions.includes(name)) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || additionalTestBlockFunctions.includes(name)) {
           if (node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'todo')) {
             return;
           }

package/lib/rules/max-nested-describe.js

@@ -46,7 +46,7 @@ var _default = (0, _utils2.createRule)({
         parent
       } = node;
 
-      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression || !(0, _utils2.isDescribeCall)(parent)) {
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression || !(0, _utils2.isTypeOfJestFnCall)(parent, context, ['describe'])) {
         return;
       }
 
@@ -69,7 +69,7 @@ var _default = (0, _utils2.createRule)({
         parent
       } = node;
 
-      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isDescribeCall)(parent)) {
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTypeOfJestFnCall)(parent, context, ['describe'])) {
         describeCallbackStack.pop();
       }
     }

package/lib/rules/no-alias-methods.js

@@ -64,7 +64,7 @@ var _default = (0, _utils.createRule)({
               canonical
             },
             node: matcher.node.property,
-            fix: fixer => [fixer.replaceText(matcher.node.property, canonical)]
+            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, canonical)]
           });
         }
       }

package/lib/rules/no-conditional-expect.js

@@ -39,7 +39,7 @@ var _default = (0, _utils2.createRule)({
     return {
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables, context);
 
         if (testCallExpressions.length > 0) {
           inTestCase = true;
@@ -47,7 +47,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils2.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
           inTestCase = true;
         }
 
@@ -71,7 +71,7 @@ var _default = (0, _utils2.createRule)({
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils2.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
           inTestCase = false;
         }
 

package/lib/rules/no-conditional-in-test.js

@@ -37,13 +37,13 @@ var _default = (0, _utils.createRule)({
 
     return {
       CallExpression(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['test'])) {
           inTestCase = true;
         }
       },
 
       'CallExpression:exit'(node) {
-        if ((0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['test'])) {
           inTestCase = false;
         }
       },

package/lib/rules/no-deprecated-functions.js

@@ -7,8 +7,6 @@ exports.default = void 0;
 
 var _utils = require("@typescript-eslint/utils");
 
-var _detectJestVersion = require("./detectJestVersion");
-
 var _utils2 = require("./utils");
 
 const parseJestVersion = rawVersion => {
@@ -40,7 +38,7 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     var _context$settings, _context$settings$jes;
 
-    const jestVersion = parseJestVersion(((_context$settings = context.settings) === null || _context$settings === void 0 ? void 0 : (_context$settings$jes = _context$settings.jest) === null || _context$settings$jes === void 0 ? void 0 : _context$settings$jes.version) || (0, _detectJestVersion.detectJestVersion)());
+    const jestVersion = parseJestVersion(((_context$settings = context.settings) === null || _context$settings === void 0 ? void 0 : (_context$settings$jes = _context$settings.jest) === null || _context$settings$jes === void 0 ? void 0 : _context$settings$jes.version) || (0, _utils2.detectJestVersion)());
     const deprecations = { ...(jestVersion >= 15 && {
         'jest.resetModuleRegistry': 'jest.resetModules'
       }),

package/lib/rules/no-disabled-tests.js

@@ -17,8 +17,6 @@ var _default = (0, _utils.createRule)({
     },
     messages: {
       missingFunction: 'Test is missing function argument',
-      skippedTestSuite: 'Skipped test suite',
-      skippedTest: 'Skipped test',
       pending: 'Call to pending()',
       pendingSuite: 'Call to pending() within test suite',
       pendingTest: 'Call to pending() within test',
@@ -34,51 +32,50 @@ var _default = (0, _utils.createRule)({
     let suiteDepth = 0;
     let testDepth = 0;
     return {
-      'CallExpression[callee.name="describe"]'() {
-        suiteDepth++;
-      },
-
-      'CallExpression[callee.name=/^(it|test)$/]'() {
-        testDepth++;
-      },
-
-      'CallExpression[callee.name=/^(it|test)$/][arguments.length<2]'(node) {
-        context.report({
-          messageId: 'missingFunction',
-          node
-        });
-      },
-
       CallExpression(node) {
-        const functionName = (0, _utils.getNodeName)(node.callee); // prevent duplicate warnings for it.each()()
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
 
-        if (node.callee.type === 'CallExpression') {
+        if (!jestFnCall) {
           return;
         }
 
-        switch (functionName) {
-          case 'describe.skip.each':
-          case 'xdescribe.each':
-          case 'describe.skip':
-            context.report({
-              messageId: 'skippedTestSuite',
-              node
-            });
-            break;
-
-          case 'it.skip':
-          case 'it.concurrent.skip':
-          case 'test.skip':
-          case 'test.concurrent.skip':
-          case 'it.skip.each':
-          case 'test.skip.each':
-          case 'xit.each':
-          case 'xtest.each':
+        if (jestFnCall.type === 'describe') {
+          suiteDepth++;
+        }
+
+        if (jestFnCall.type === 'test') {
+          testDepth++;
+
+          if (node.arguments.length < 2 && jestFnCall.members.every(s => (0, _utils.getAccessorValue)(s) !== 'todo')) {
             context.report({
-              messageId: 'skippedTest',
+              messageId: 'missingFunction',
               node
             });
-            break;
+          }
+        }
+
+        if ( // the only jest functions that are with "x" are "xdescribe", "xtest", and "xit"
+        jestFnCall.name.startsWith('x') || jestFnCall.members.some(s => (0, _utils.getAccessorValue)(s) === 'skip')) {
+          context.report({
+            messageId: jestFnCall.type === 'describe' ? 'disabledSuite' : 'disabledTest',
+            node
+          });
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if (!jestFnCall) {
+          return;
+        }
+
+        if (jestFnCall.type === 'describe') {
+          suiteDepth--;
+        }
+
+        if (jestFnCall.type === 'test') {
+          testDepth--;
         }
       },
 
@@ -103,28 +100,6 @@ var _default = (0, _utils.createRule)({
             node
           });
         }
-      },
-
-      'CallExpression[callee.name="xdescribe"]'(node) {
-        context.report({
-          messageId: 'disabledSuite',
-          node
-        });
-      },
-
-      'CallExpression[callee.name=/^(xit|xtest)$/]'(node) {
-        context.report({
-          messageId: 'disabledTest',
-          node
-        });
-      },
-
-      'CallExpression[callee.name="describe"]:exit'() {
-        suiteDepth--;
-      },
-
-      'CallExpression[callee.name=/^(it|test)$/]:exit'() {
-        testDepth--;
       }
 
     };