eslint-plugin-jest 25.3.1 → 25.4.0

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+# [25.4.0](https://github.com/jest-community/eslint-plugin-jest/compare/v25.3.4...v25.4.0) (2022-01-15)
+
+
+### Features
+
+* **prefer-expect-assertions:** support requiring only if `expect` is used in a loop ([#1013](https://github.com/jest-community/eslint-plugin-jest/issues/1013)) ([e6f4f8a](https://github.com/jest-community/eslint-plugin-jest/commit/e6f4f8aaf7664bcf9d9d5549c3c43b1b09f49461))
+
+## [25.3.4](https://github.com/jest-community/eslint-plugin-jest/compare/v25.3.3...v25.3.4) (2022-01-01)
+
+
+### Bug Fixes
+
+* **prefer-lowercase-title:** ignore `it` and `test` separately ([#1011](https://github.com/jest-community/eslint-plugin-jest/issues/1011)) ([f1a7674](https://github.com/jest-community/eslint-plugin-jest/commit/f1a767400967bd923512f79e80f283b3b2afa772))
+
+## [25.3.3](https://github.com/jest-community/eslint-plugin-jest/compare/v25.3.2...v25.3.3) (2021-12-30)
+
+
+### Bug Fixes
+
+* **prefer-to-contain:** support square bracket accessors ([#1009](https://github.com/jest-community/eslint-plugin-jest/issues/1009)) ([73984a7](https://github.com/jest-community/eslint-plugin-jest/commit/73984a79f790986a17116589a587506bcc10efc0))
+* **prefer-to-have-length:** support square bracket accessors ([#1010](https://github.com/jest-community/eslint-plugin-jest/issues/1010)) ([9e70f55](https://github.com/jest-community/eslint-plugin-jest/commit/9e70f550e341432f69a1cd334c19df87513ea906))
+
+## [25.3.2](https://github.com/jest-community/eslint-plugin-jest/compare/v25.3.1...v25.3.2) (2021-12-27)
+
+
+### Bug Fixes
+
+* **no-large-snapshots:** only count size of template string for inline snapshots ([#1005](https://github.com/jest-community/eslint-plugin-jest/issues/1005)) ([5bea38f](https://github.com/jest-community/eslint-plugin-jest/commit/5bea38f9773ab686f08a7cc25247a782d50aa5ed))
+* **prefer-hooks-on-top:** improve message & docs ([#999](https://github.com/jest-community/eslint-plugin-jest/issues/999)) ([f9e7ae2](https://github.com/jest-community/eslint-plugin-jest/commit/f9e7ae29233daad7bfea2230bea7266659299328))
+
 ## [25.3.1](https://github.com/jest-community/eslint-plugin-jest/compare/v25.3.0...v25.3.1) (2021-12-27)
 
 

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

@@ -58,6 +58,16 @@ test('my test', () => {
 
 ## Options
 
+This rule can be configured to only check tests that match certain patterns that
+typically look like `expect` calls might be missed, such as in promises or
+loops.
+
+By default, none of these options are enabled meaning the rule checks _every_
+test for a call to either `expect.hasAssertions` or `expect.assertions`. If any
+of the options are enabled the rule checks any test that matches _at least one_
+of the patterns represented by the enabled options (think "OR" rather than
+"AND").
+
 #### `onlyFunctionsWithAsyncKeyword`
 
 When `true`, this rule will only warn for tests that use the `async` keyword.
@@ -97,3 +107,53 @@ test('my test', async () => {
   expect(result).toBe('foo');
 });
 ```
+
+#### `onlyFunctionsWithExpectInLoop`
+
+When `true`, this rule will only warn for tests that have `expect` calls within
+a native loop.
+
+```json
+{
+  "rules": {
+    "jest/prefer-expect-assertions": [
+      "warn",
+      { "onlyFunctionsWithAsyncKeyword": true }
+    ]
+  }
+}
+```
+
+Examples of **incorrect** code when `'onlyFunctionsWithExpectInLoop'` is `true`:
+
+```js
+describe('getNumbers', () => {
+  it('only returns numbers that are greater than zero', () => {
+    const numbers = getNumbers();
+
+    for (const number in numbers) {
+      expect(number).toBeGreaterThan(0);
+    }
+  });
+});
+```
+
+Examples of **correct** code when `'onlyFunctionsWithExpectInLoop'` is `true`:
+
+```js
+describe('getNumbers', () => {
+  it('only returns numbers that are greater than zero', () => {
+    expect.hasAssertions();
+
+    const numbers = getNumbers();
+
+    for (const number in numbers) {
+      expect(number).toBeGreaterThan(0);
+    }
+  });
+
+  it('returns more than one number', () => {
+    expect(getNumbers().length).toBeGreaterThan(1);
+  });
+});
+```

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

@@ -1,6 +1,10 @@
 # Suggest having hooks before any test cases (`prefer-hooks-on-top`)
 
-All hooks should be defined before the start of the tests
+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
+cases.
+
+This rule helps to ensure that hooks are always defined before test cases.
 
 ## Rule Details
 
@@ -11,47 +15,51 @@ Examples of **incorrect** code for this rule
 
 describe('foo', () => {
   beforeEach(() => {
-    //some hook code
-  });
-  test('bar', () => {
-    some_fn();
+    seedMyDatabase();
   });
-  beforeAll(() => {
-    //some hook code
-  });
-  test('bar', () => {
-    some_fn();
+
+  it('accepts this input', () => {
+    // ...
   });
-});
 
-// Nested describe scenario
-describe('foo', () => {
   beforeAll(() => {
-    //some hook code
+    createMyDatabase();
   });
-  test('bar', () => {
-    some_fn();
+
+  it('returns that value', () => {
+    // ...
   });
-  describe('inner_foo', () => {
+
+  describe('when the database has specific values', () => {
+    const specificValue = '...';
+
     beforeEach(() => {
-      //some hook code
+      seedMyDatabase(specificValue);
     });
-    test('inner bar', () => {
-      some_fn();
+
+    it('accepts that input', () => {
+      // ...
     });
-    test('inner bar', () => {
-      some_fn();
+
+    it('throws an error', () => {
+      // ...
     });
-    beforeAll(() => {
-      //some hook code
+
+    afterEach(() => {
+      clearLogger();
     });
-    afterAll(() => {
-      //some hook code
+    beforeEach(() => {
+      mockLogger();
     });
-    test('inner bar', () => {
-      some_fn();
+
+    it('logs a message', () => {
+      // ...
     });
   });
+
+  afterAll(() => {
+    removeMyDatabase();
+  });
 });
 ```
 
@@ -61,35 +69,51 @@ Examples of **correct** code for this rule
 /* eslint jest/prefer-hooks-on-top: "error" */
 
 describe('foo', () => {
-  beforeEach(() => {
-    //some hook code
+  beforeAll(() => {
+    createMyDatabase();
   });
 
-  // Not affected by rule
-  someSetup();
-
-  afterEach(() => {
-    //some hook code
+  beforeEach(() => {
+    seedMyDatabase();
   });
-  test('bar', () => {
-    some_fn();
+
+  afterAll(() => {
+    clearMyDatabase();
   });
-});
 
-// Nested describe scenario
-describe('foo', () => {
-  beforeEach(() => {
-    //some hook code
+  it('accepts this input', () => {
+    // ...
   });
-  test('bar', () => {
-    some_fn();
+
+  it('returns that value', () => {
+    // ...
   });
-  describe('inner_foo', () => {
+
+  describe('when the database has specific values', () => {
+    const specificValue = '...';
+
     beforeEach(() => {
-      //some hook code
+      seedMyDatabase(specificValue);
     });
-    test('inner bar', () => {
-      some_fn();
+
+    beforeEach(() => {
+      mockLogger();
+    });
+
+    afterEach(() => {
+      clearLogger();
+    });
+
+    it('accepts that input', () => {
+      // ...
+    });
+
+    it('throws an error', () => {
+      // ...
+    });
+
+    it('logs a message', () => {
+      // ...
     });
   });
 });

package/lib/rules/no-large-snapshots.js

@@ -100,6 +100,8 @@ var _default = (0, _utils.createRule)({
 
     return {
       CallExpression(node) {
+        var _matcher$arguments;
+
         if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
@@ -112,10 +114,10 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name)) {
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name) && (_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length) {
           var _options$inlineMaxSiz;
 
-          reportOnViolation(context, matcher.node.parent, { ...options,
+          reportOnViolation(context, matcher.arguments[0], { ...options,
             maxSize: (_options$inlineMaxSiz = options.inlineMaxSize) !== null && _options$inlineMaxSiz !== void 0 ? _options$inlineMaxSiz : options.maxSize
           });
         }

package/lib/rules/prefer-expect-assertions.js

@@ -45,18 +45,68 @@ var _default = (0, _utils.createRule)({
       properties: {
         onlyFunctionsWithAsyncKeyword: {
           type: 'boolean'
+        },
+        onlyFunctionsWithExpectInLoop: {
+          type: 'boolean'
         }
       },
       additionalProperties: false
     }]
   },
   defaultOptions: [{
-    onlyFunctionsWithAsyncKeyword: false
+    onlyFunctionsWithAsyncKeyword: false,
+    onlyFunctionsWithExpectInLoop: false
   }],
 
   create(context, [options]) {
+    let hasExpectInLoop = false;
+    let inTestCaseCall = false;
+    let inForLoop = false;
+
+    const shouldCheckFunction = testFunction => {
+      if (!options.onlyFunctionsWithAsyncKeyword && !options.onlyFunctionsWithExpectInLoop) {
+        return true;
+      }
+
+      if (options.onlyFunctionsWithAsyncKeyword) {
+        if (testFunction.async) {
+          return true;
+        }
+      }
+
+      if (options.onlyFunctionsWithExpectInLoop) {
+        if (hasExpectInLoop) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    const enterForLoop = () => inForLoop = true;
+
+    const exitForLoop = () => inForLoop = false;
+
     return {
+      ForStatement: enterForLoop,
+      'ForStatement:exit': exitForLoop,
+      ForInStatement: enterForLoop,
+      'ForInStatement:exit': exitForLoop,
+      ForOfStatement: enterForLoop,
+      'ForOfStatement:exit': exitForLoop,
+
       CallExpression(node) {
+        if ((0, _utils.isTestCaseCall)(node)) {
+          inTestCaseCall = true;
+          return;
+        }
+
+        if ((0, _utils.isExpectCall)(node) && inTestCaseCall && inForLoop) {
+          hasExpectInLoop = true;
+        }
+      },
+
+      'CallExpression:exit'(node) {
         if (!(0, _utils.isTestCaseCall)(node)) {
           return;
         }
@@ -67,10 +117,15 @@ var _default = (0, _utils.createRule)({
 
         const [, testFn] = node.arguments;
 
-        if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement || options.onlyFunctionsWithAsyncKeyword && !testFn.async) {
+        if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+          return;
+        }
+
+        if (!shouldCheckFunction(testFn)) {
           return;
         }
 
+        hasExpectInLoop = false;
         const testFuncBody = testFn.body.body;
 
         if (!isFirstLineExprStmt(testFuncBody)) {

package/lib/rules/prefer-hooks-on-top.js

@@ -16,7 +16,7 @@ var _default = (0, _utils.createRule)({
       recommended: false
     },
     messages: {
-      noHookOnTop: 'Move all hooks before test cases'
+      noHookOnTop: 'Hooks should come before test cases'
     },
     schema: [],
     type: 'suggestion'

package/lib/rules/prefer-lowercase-title.js

@@ -29,11 +29,11 @@ const populateIgnores = ignore => {
   }
 
   if (ignore.includes(_utils.TestCaseName.test)) {
-    ignores.push(...Object.keys(_utils.TestCaseName));
+    ignores.push(...Object.keys(_utils.TestCaseName).filter(k => k.endsWith(_utils.TestCaseName.test)));
   }
 
   if (ignore.includes(_utils.TestCaseName.it)) {
-    ignores.push(...Object.keys(_utils.TestCaseName));
+    ignores.push(...Object.keys(_utils.TestCaseName).filter(k => k.endsWith(_utils.TestCaseName.it)));
   }
 
   return ignores;

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

@@ -32,52 +32,8 @@ const isBooleanEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCa
  * @param {CallExpression} node
  *
  * @return {node is FixableIncludesCallExpression}
- *
- * @todo support `['includes']()` syntax (remove last property.type check to begin)
- * @todo break out into `isMethodCall<Name extends string>(node: TSESTree.Node, method: Name)` util-fn
- */
-const isFixableIncludesCallExpression = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'includes') && node.callee.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && (0, _utils.hasOnlyOneArgument)(node);
-
-const buildToContainFuncExpectation = negated => negated ? `${_utils.ModifierName.not}.toContain` : 'toContain';
-/**
- * Finds the first `.` character token between the `object` & `property` of the given `member` expression.
- *
- * @param {TSESTree.MemberExpression} member
- * @param {SourceCode} sourceCode
- *
- * @return {Token | null}
  */
-
-
-const findPropertyDotToken = (member, sourceCode) => sourceCode.getFirstTokenBetween(member.object, member.property, token => token.value === '.');
-
-const getNegationFixes = (node, modifier, matcher, sourceCode, fixer, fileName) => {
-  const [containArg] = node.arguments;
-  const negationPropertyDot = findPropertyDotToken(modifier.node, sourceCode);
-  const toContainFunc = buildToContainFuncExpectation((0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value);
-  /* istanbul ignore if */
-
-  if (negationPropertyDot === null) {
-    throw new Error(`Unexpected null when attempting to fix ${fileName} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-  }
-
-  return [fixer.remove(negationPropertyDot), fixer.remove(modifier.node.property), fixer.replaceText(matcher.node.property, toContainFunc), fixer.replaceText(matcher.arguments[0], sourceCode.getText(containArg))];
-};
-
-const getCommonFixes = (node, sourceCode, fileName) => {
-  const [containArg] = node.arguments;
-  const includesCallee = node.callee;
-  const propertyDot = findPropertyDotToken(includesCallee, sourceCode);
-  const closingParenthesis = sourceCode.getTokenAfter(containArg);
-  const openParenthesis = sourceCode.getTokenBefore(containArg);
-  /* istanbul ignore if */
-
-  if (propertyDot === null || closingParenthesis === null || openParenthesis === null) {
-    throw new Error(`Unexpected null when attempting to fix ${fileName} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-  }
-
-  return [containArg, includesCallee.property, propertyDot, closingParenthesis, openParenthesis];
-}; // expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
+const isFixableIncludesCallExpression = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'includes') && (0, _utils.hasOnlyOneArgument)(node); // expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
 
 
 var _default = (0, _utils.createRule)({
@@ -106,7 +62,8 @@ var _default = (0, _utils.createRule)({
 
         const {
           expect: {
-            arguments: [includesCall]
+            arguments: [includesCall],
+            range: [, expectCallEnd]
           },
           matcher,
           modifier
@@ -118,19 +75,14 @@ var _default = (0, _utils.createRule)({
 
         context.report({
           fix(fixer) {
-            const sourceCode = context.getSourceCode();
-            const fileName = context.getFilename();
-            const fixArr = getCommonFixes(includesCall, sourceCode, fileName).map(target => fixer.remove(target));
-
-            if (modifier) {
-              return getNegationFixes(includesCall, modifier, matcher, sourceCode, fixer, fileName).concat(fixArr);
-            }
-
-            const toContainFunc = buildToContainFuncExpectation(!(0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value);
-            const [containArg] = includesCall.arguments;
-            fixArr.push(fixer.replaceText(matcher.node.property, toContainFunc));
-            fixArr.push(fixer.replaceText(matcher.arguments[0], sourceCode.getText(containArg)));
-            return fixArr;
+            const sourceCode = context.getSourceCode(); // we need to negate the expectation if the current expected
+            // value is itself negated by the "not" modifier
+
+            const addNotModifier = (0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value === !!modifier;
+            return [// remove the "includes" call entirely
+            fixer.removeRange([includesCall.callee.property.range[0] - 1, includesCall.range[1]]), // replace the current matcher with "toContain", adding "not" if needed
+            fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], addNotModifier ? `.${_utils.ModifierName.not}.toContain` : '.toContain'), // replace the matcher argument with the value from the "includes"
+            fixer.replaceText(matcher.arguments[0], sourceCode.getText(includesCall.arguments[0]))];
           },
 
           messageId: 'useToContain',

package/lib/rules/prefer-to-have-length.js

@@ -40,20 +40,15 @@ var _default = (0, _utils.createRule)({
           matcher
         } = (0, _utils.parseExpectCall)(node);
 
-        if (!matcher || !(0, _utils.isParsedEqualityMatcherCall)(matcher) || (argument === null || argument === void 0 ? void 0 : argument.type) !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || !(0, _utils.isSupportedAccessor)(argument.property, 'length') || argument.property.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
+        if (!matcher || !(0, _utils.isParsedEqualityMatcherCall)(matcher) || (argument === null || argument === void 0 ? void 0 : argument.type) !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || !(0, _utils.isSupportedAccessor)(argument.property, 'length')) {
           return;
         }
 
         context.report({
           fix(fixer) {
-            const propertyDot = context.getSourceCode().getFirstTokenBetween(argument.object, argument.property, token => token.value === '.');
-            /* istanbul ignore if */
-
-            if (propertyDot === null) {
-              throw new Error(`Unexpected null when attempting to fix ${context.getFilename()} - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`);
-            }
-
-            return [fixer.remove(propertyDot), fixer.remove(argument.property), fixer.replaceText(matcher.node.property, 'toHaveLength')];
+            return [// remove the "length" property accessor
+            fixer.removeRange([argument.property.range[0] - 1, argument.range[1]]), // replace the current matcher with "toHaveLength"
+            fixer.replaceTextRange([matcher.node.object.range[1], matcher.node.range[1]], '.toHaveLength')];
           },
 
           messageId: 'useToHaveLength',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "25.3.1",
+  "version": "25.4.0",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -89,8 +89,8 @@
     "@babel/core": "^7.4.4",
     "@babel/preset-env": "^7.4.4",
     "@babel/preset-typescript": "^7.3.3",
-    "@commitlint/cli": "^15.0.0",
-    "@commitlint/config-conventional": "^15.0.0",
+    "@commitlint/cli": "^16.0.0",
+    "@commitlint/config-conventional": "^16.0.0",
     "@schemastore/package": "^0.0.6",
     "@semantic-release/changelog": "^6.0.0",
     "@semantic-release/git": "^10.0.0",
@@ -111,6 +111,8 @@
     "eslint-plugin-import": "^2.25.1",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.4.1",
+    "eslint-remote-tester": "^2.1.0",
+    "eslint-remote-tester-repositories": "^0.0.3",
     "husky": "^7.0.2",
     "is-ci": "^3.0.0",
     "jest": "^27.0.0",