eslint-plugin-jest 25.4.0 → 25.5.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [25.5.0](https://github.com/jest-community/eslint-plugin-jest/compare/v25.4.0...v25.5.0) (2022-01-15)
+
+
+### Features
+
+* **prefer-expect-assertions:** support requiring only if `expect` is used in a callback ([#1028](https://github.com/jest-community/eslint-plugin-jest/issues/1028)) ([8d5fd33](https://github.com/jest-community/eslint-plugin-jest/commit/8d5fd33eed633f0c0bbdcb9e86bd2d8d7de79c4b))
+
 # [25.4.0](https://github.com/jest-community/eslint-plugin-jest/compare/v25.3.4...v25.4.0) (2022-01-15)
 
 

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

@@ -157,3 +157,69 @@ describe('getNumbers', () => {
   });
 });
 ```
+
+#### `onlyFunctionsWithExpectInCallback`
+
+When `true`, this rule will only warn for tests that have `expect` calls within
+a callback.
+
+```json
+{
+  "rules": {
+    "jest/prefer-expect-assertions": [
+      "warn",
+      { "onlyFunctionsWithExpectInCallback": true }
+    ]
+  }
+}
+```
+
+Examples of **incorrect** code when `'onlyFunctionsWithExpectInCallback'` is
+`true`:
+
+```js
+describe('getNumbers', () => {
+  it('only returns numbers that are greater than zero', () => {
+    const numbers = getNumbers();
+
+    getNumbers().forEach(number => {
+      expect(number).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe('/users', () => {
+  it.each([1, 2, 3])('returns ok', id => {
+    client.get(`/users/${id}`, response => {
+      expect(response.status).toBe(200);
+    });
+  });
+});
+```
+
+Examples of **correct** code when `'onlyFunctionsWithExpectInCallback'` is
+`true`:
+
+```js
+describe('getNumbers', () => {
+  it('only returns numbers that are greater than zero', () => {
+    expect.hasAssertions();
+
+    const numbers = getNumbers();
+
+    getNumbers().forEach(number => {
+      expect(number).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe('/users', () => {
+  it.each([1, 2, 3])('returns ok', id => {
+    expect.assertions(3);
+
+    client.get(`/users/${id}`, response => {
+      expect(response.status).toBe(200);
+    });
+  });
+});
+```

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

@@ -48,6 +48,9 @@ var _default = (0, _utils.createRule)({
         },
         onlyFunctionsWithExpectInLoop: {
           type: 'boolean'
+        },
+        onlyFunctionsWithExpectInCallback: {
+          type: 'boolean'
         }
       },
       additionalProperties: false
@@ -55,16 +58,19 @@ var _default = (0, _utils.createRule)({
   },
   defaultOptions: [{
     onlyFunctionsWithAsyncKeyword: false,
-    onlyFunctionsWithExpectInLoop: false
+    onlyFunctionsWithExpectInLoop: false,
+    onlyFunctionsWithExpectInCallback: false
   }],
 
   create(context, [options]) {
+    let expressionDepth = 0;
+    let hasExpectInCallback = false;
     let hasExpectInLoop = false;
     let inTestCaseCall = false;
     let inForLoop = false;
 
     const shouldCheckFunction = testFunction => {
-      if (!options.onlyFunctionsWithAsyncKeyword && !options.onlyFunctionsWithExpectInLoop) {
+      if (!options.onlyFunctionsWithAsyncKeyword && !options.onlyFunctionsWithExpectInLoop && !options.onlyFunctionsWithExpectInCallback) {
         return true;
       }
 
@@ -80,14 +86,28 @@ var _default = (0, _utils.createRule)({
         }
       }
 
+      if (options.onlyFunctionsWithExpectInCallback) {
+        if (hasExpectInCallback) {
+          return true;
+        }
+      }
+
       return false;
     };
 
+    const enterExpression = () => inTestCaseCall && expressionDepth++;
+
+    const exitExpression = () => inTestCaseCall && expressionDepth--;
+
     const enterForLoop = () => inForLoop = true;
 
     const exitForLoop = () => inForLoop = false;
 
     return {
+      FunctionExpression: enterExpression,
+      'FunctionExpression:exit': exitExpression,
+      ArrowFunctionExpression: enterExpression,
+      'ArrowFunctionExpression:exit': exitExpression,
       ForStatement: enterForLoop,
       'ForStatement:exit': exitForLoop,
       ForInStatement: enterForLoop,
@@ -101,8 +121,14 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if ((0, _utils.isExpectCall)(node) && inTestCaseCall && inForLoop) {
-          hasExpectInLoop = true;
+        if ((0, _utils.isExpectCall)(node) && inTestCaseCall) {
+          if (inForLoop) {
+            hasExpectInLoop = true;
+          }
+
+          if (expressionDepth > 1) {
+            hasExpectInCallback = true;
+          }
         }
       },
 
@@ -126,6 +152,7 @@ var _default = (0, _utils.createRule)({
         }
 
         hasExpectInLoop = false;
+        hasExpectInCallback = false;
         const testFuncBody = testFn.body.body;
 
         if (!isFirstLineExprStmt(testFuncBody)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "25.4.0",
+  "version": "25.5.0",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",