eslint-plugin-jest 23.14.0 → 23.17.1

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## [23.17.1](https://github.com/jest-community/eslint-plugin-jest/compare/v23.17.0...v23.17.1) (2020-06-23)
+
+
+### Bug Fixes
+
+* **lowercase-name:** ignore all top level describes when option is true ([#614](https://github.com/jest-community/eslint-plugin-jest/issues/614)) ([624018a](https://github.com/jest-community/eslint-plugin-jest/commit/624018aa181e7c0ce87457a4f9c212c7891987a8)), closes [#613](https://github.com/jest-community/eslint-plugin-jest/issues/613)
+
+# [23.17.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.16.0...v23.17.0) (2020-06-23)
+
+
+### Features
+
+* **lowercase-name:** support `ignoreTopLevelDescribe` option ([#611](https://github.com/jest-community/eslint-plugin-jest/issues/611)) ([36fdcc5](https://github.com/jest-community/eslint-plugin-jest/commit/36fdcc553ca40bc2ca2e9ca7e04f8e9e4a315274)), closes [#247](https://github.com/jest-community/eslint-plugin-jest/issues/247)
+
+# [23.16.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.15.0...v23.16.0) (2020-06-21)
+
+
+### Features
+
+* create `no-conditional-expect` rule ([aba53e4](https://github.com/jest-community/eslint-plugin-jest/commit/aba53e4061f3b636ab0c0270e183c355c6f301e0))
+* deprecate `no-try-expect` in favor of `no-conditional-expect` ([6d07cad](https://github.com/jest-community/eslint-plugin-jest/commit/6d07cadd5f78ed7a64a86792931d49d3cd943d69))
+
+# [23.15.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.14.0...v23.15.0) (2020-06-21)
+
+
+### Features
+
+* **no-standalone-expect:** support `additionalTestBlockFunctions` ([#585](https://github.com/jest-community/eslint-plugin-jest/issues/585)) ([ed220b2](https://github.com/jest-community/eslint-plugin-jest/commit/ed220b2c515f2e97ce639dd1474c18a7f594c06c))
+
 # [23.14.0](https://github.com/jest-community/eslint-plugin-jest/compare/v23.13.2...v23.14.0) (2020-06-20)
 
 

package/README.md

@@ -134,6 +134,7 @@ installations requiring long-term consistency.
 | [lowercase-name](docs/rules/lowercase-name.md)                         | Enforce lowercase test names                                    |                  | ![fixable][] |
 | [no-alias-methods](docs/rules/no-alias-methods.md)                     | Disallow alias methods                                          | ![style][]       | ![fixable][] |
 | [no-commented-out-tests](docs/rules/no-commented-out-tests.md)         | Disallow commented out tests                                    | ![recommended][] |              |
+| [no-conditional-expect](docs/rules/no-conditional-expect.md)           | Prevent calling `expect` conditionally                          |                  |              |
 | [no-deprecated-functions](docs/rules/no-deprecated-functions.md)       | Disallow use of deprecated functions                            |                  | ![fixable][] |
 | [no-disabled-tests](docs/rules/no-disabled-tests.md)                   | Disallow disabled tests                                         | ![recommended][] |              |
 | [no-duplicate-hooks](docs/rules/no-duplicate-hooks.md)                 | Disallow duplicate setup and teardown hooks                     |                  |              |
@@ -151,7 +152,6 @@ installations requiring long-term consistency.
 | [no-test-callback](docs/rules/no-test-callback.md)                     | Avoid using a callback in asynchronous tests                    | ![recommended][] | ![suggest][] |
 | [no-test-prefixes](docs/rules/no-test-prefixes.md)                     | Use `.only` and `.skip` over `f` and `x`                        | ![recommended][] | ![fixable][] |
 | [no-test-return-statement](docs/rules/no-test-return-statement.md)     | Disallow explicitly returning from tests                        |                  |              |
-| [no-try-expect](docs/rules/no-try-expect.md)                           | Prefer using toThrow for exception tests                        | ![recommended][] |              |
 | [prefer-called-with](docs/rules/prefer-called-with.md)                 | Suggest using `toBeCalledWith()` OR `toHaveBeenCalledWith()`    |                  |              |
 | [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)     | Suggest using `expect.assertions()` OR `expect.hasAssertions()` |                  | ![suggest][] |
 | [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)               | Suggest to have all hooks at top level                          |                  |              |

package/docs/rules/lowercase-name.md

@@ -86,3 +86,21 @@ Example of **correct** code for the `{ "allowedPrefixes": ["GET"] }` option:
 
 describe('GET /live');
 ```
+
+### `ignoreTopLevelDescribe`
+
+This option can be set to allow only the top-level `describe` blocks to have a
+title starting with an upper-case letter.
+
+Example of **correct** code for the `{ "ignoreTopLevelDescribe": true }` option:
+
+```js
+/* eslint jest/lowercase-name: ["error", { "ignoreTopLevelDescribe": true }] */
+describe('MyClass', () => {
+  describe('#myMethod', () => {
+    it('does things', () => {
+      //
+    });
+  });
+});
+```

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

@@ -0,0 +1,70 @@
+# Prevent calling `expect` conditionally (`no-conditional-expect`)
+
+This rule prevents the use of `expect` in conditional blocks, such as `if`s &
+`catch`s.
+
+## Rule Details
+
+Jest considered a test to have failed if it throws an error, rather than on if
+any particular function is called, meaning conditional calls to `expect` could
+result in tests silently being skipped.
+
+Additionally, conditionals tend to make tests more brittle and complex, as they
+increase the amount of mental thinking needed to understand what is actually
+being tested.
+
+While `expect.assertions` & `expect.hasAssertions` can help prevent tests from
+silently being skipped, when combined with conditionals they typically result in
+even more complexity being introduced.
+
+The following patterns are warnings:
+
+```js
+it('foo', () => {
+  doTest && expect(1).toBe(2);
+});
+
+it('bar', () => {
+  if (!skipTest) {
+    expect(1).toEqual(2);
+  }
+});
+
+it('baz', async () => {
+  try {
+    await foo();
+  } catch (err) {
+    expect(err).toMatchObject({ code: 'MODULE_NOT_FOUND' });
+  }
+});
+```
+
+The following patterns are not warnings:
+
+```js
+it('foo', () => {
+  expect(!value).toBe(false);
+});
+
+function getValue() {
+  if (process.env.FAIL) {
+    return 1;
+  }
+
+  return 2;
+}
+
+it('foo', () => {
+  expect(getValue()).toBe(2);
+});
+
+it('validates the request', () => {
+  try {
+    processRequest(request);
+  } catch {
+    // ignore errors
+  } finally {
+    expect(validRequest).toHaveBeenCalledWith(request);
+  }
+});
+```

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

@@ -64,6 +64,36 @@ describe('a test', () => {
 thought the `expect` will not execute. Rely on a rule like no-unused-vars for
 this case.
 
+### Options
+
+#### `additionalTestBlockFunctions`
+
+This array can be used to specify the names of functions that should also be
+treated as test blocks:
+
+```json
+{
+  "rules": {
+    "jest/no-standalone-expect": [
+      "error",
+      { "additionalTestBlockFunctions": ["each.test"] }
+    ]
+  }
+}
+```
+
+The following is _correct_ when using the above configuration:
+
+```js
+each([
+  [1, 1, 2],
+  [1, 2, 3],
+  [2, 1, 3],
+]).test('returns the result of adding %d to %d', (a, b, expected) => {
+  expect(a + b).toBe(expected);
+});
+```
+
 ## When Not To Use It
 
 Don't use this rule on non-jest test files.

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

@@ -1,5 +1,12 @@
 # Prevent catch assertions in tests (`no-try-expect`)
 
+## Deprecated
+
+This rule has been deprecated in favor of
+[`no-conditional-expect`](no-conditional-expect.md).
+
+---
+
 This rule prevents the use of `expect` inside `catch` blocks.
 
 ## Rule Details

package/lib/rules/lowercase-name.js

@@ -58,6 +58,10 @@ var _default = (0, _utils.createRule)({
             type: 'string'
           },
           additionalItems: false
+        },
+        ignoreTopLevelDescribe: {
+          type: 'boolean',
+          default: false
         }
       },
       additionalProperties: false
@@ -65,19 +69,30 @@ var _default = (0, _utils.createRule)({
   },
   defaultOptions: [{
     ignore: [],
-    allowedPrefixes: []
+    allowedPrefixes: [],
+    ignoreTopLevelDescribe: false
   }],
 
   create(context, [{
     ignore = [],
-    allowedPrefixes = []
+    allowedPrefixes = [],
+    ignoreTopLevelDescribe
   }]) {
+    let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
         if (!isJestFunctionWithLiteralArg(node)) {
           return;
         }
 
+        if ((0, _utils.isDescribe)(node)) {
+          numberOfDescribeBlocks++;
+
+          if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1) {
+            return;
+          }
+        }
+
         const erroneousMethod = jestFunctionName(node, allowedPrefixes);
 
         if (erroneousMethod && !ignore.includes(node.callee.name)) {
@@ -98,6 +113,12 @@ var _default = (0, _utils.createRule)({
 
           });
         }
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isDescribe)(node)) {
+          numberOfDescribeBlocks--;
+        }
       }
 
     };

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

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      description: 'Prevent calling `expect` conditionally',
+      category: 'Best Practices',
+      recommended: false
+    },
+    messages: {
+      conditionalExpect: 'Avoid calling `expect` conditionally`'
+    },
+    type: 'problem',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    let conditionalDepth = 0;
+    let inTestCase = false;
+
+    const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
+
+    const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
+
+    return {
+      FunctionDeclaration(node) {
+        const declaredVariables = context.getDeclaredVariables(node);
+        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+
+        if (testCallExpressions.length > 0) {
+          inTestCase = true;
+        }
+      },
+
+      CallExpression(node) {
+        if ((0, _utils.isTestCase)(node)) {
+          inTestCase = true;
+        }
+
+        if (inTestCase && (0, _utils.isExpectCall)(node) && conditionalDepth > 0) {
+          context.report({
+            messageId: 'conditionalExpect',
+            node
+          });
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        if ((0, _utils.isTestCase)(node)) {
+          inTestCase = false;
+        }
+      },
+
+      CatchClause: increaseConditionalDepth,
+      'CatchClause:exit': decreaseConditionalDepth,
+      IfStatement: increaseConditionalDepth,
+      'IfStatement:exit': decreaseConditionalDepth,
+      SwitchStatement: increaseConditionalDepth,
+      'SwitchStatement:exit': decreaseConditionalDepth,
+      ConditionalExpression: increaseConditionalDepth,
+      'ConditionalExpression:exit': decreaseConditionalDepth,
+      LogicalExpression: increaseConditionalDepth,
+      'LogicalExpression:exit': decreaseConditionalDepth
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -104,6 +104,7 @@ var _default = (0, _utils.createRule)({
           node,
 
           fix(fixer) {
+            // eslint-disable-next-line prefer-const
             let [name, func] = replacement.split('.');
 
             if (callee.property.type === _experimentalUtils.AST_NODE_TYPES.Literal) {

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

@@ -9,8 +9,8 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-const getBlockType = stmt => {
-  const func = stmt.parent;
+const getBlockType = statement => {
+  const func = statement.parent;
   /* istanbul ignore if */
 
   if (!func) {
@@ -23,7 +23,7 @@ const getBlockType = stmt => {
   }
 
   if ((0, _utils.isFunction)(func) && func.parent) {
-    const expr = func.parent; // arrowfunction or function expr
+    const expr = func.parent; // arrow function or function expr
 
     if (expr.type === _experimentalUtils.AST_NODE_TYPES.VariableDeclarator) {
       return 'function';
@@ -31,7 +31,7 @@ const getBlockType = stmt => {
 
 
     if (expr.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isDescribe)(expr)) {
-      return _utils.DescribeAlias.describe;
+      return 'describe';
     }
   }
 
@@ -52,12 +52,31 @@ var _default = (0, _utils.createRule)({
       unexpectedExpect: 'Expect must be inside of a test block.'
     },
     type: 'suggestion',
-    schema: []
+    schema: [{
+      properties: {
+        additionalTestBlockFunctions: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    }]
   },
-  defaultOptions: [],
+  defaultOptions: [{
+    additionalTestBlockFunctions: []
+  }],
 
-  create(context) {
+  create(context, [{
+    additionalTestBlockFunctions = []
+  }]) {
     const callStack = [];
+
+    const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils.getNodeName)(node) || '');
+
+    const isTestBlock = node => (0, _utils.isTestCase)(node) || isCustomTestBlockFunction(node);
+
     return {
       CallExpression(node) {
         if ((0, _utils.isExpectCall)(node)) {
@@ -73,8 +92,8 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if ((0, _utils.isTestCase)(node)) {
-          callStack.push(_utils.TestCaseName.test);
+        if (isTestBlock(node)) {
+          callStack.push('test');
         }
 
         if (node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
@@ -85,35 +104,35 @@ var _default = (0, _utils.createRule)({
       'CallExpression:exit'(node) {
         const top = callStack[callStack.length - 1];
 
-        if (((0, _utils.isTestCase)(node) && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || isEach(node)) && top === _utils.TestCaseName.test || node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && top === 'template') {
+        if (top === 'test' && (isEach(node) || isTestBlock(node) && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) || top === 'template' && node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.pop();
         }
       },
 
-      BlockStatement(stmt) {
-        const blockType = getBlockType(stmt);
+      BlockStatement(statement) {
+        const blockType = getBlockType(statement);
 
         if (blockType) {
           callStack.push(blockType);
         }
       },
 
-      'BlockStatement:exit'(stmt) {
-        const blockType = getBlockType(stmt);
-
-        if (blockType && blockType === callStack[callStack.length - 1]) {
+      'BlockStatement:exit'(statement) {
+        if (callStack[callStack.length - 1] === getBlockType(statement)) {
           callStack.pop();
         }
       },
 
       ArrowFunctionExpression(node) {
-        if (node.parent && node.parent.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
-          callStack.push('arrowFunc');
+        var _node$parent;
+
+        if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+          callStack.push('arrow');
         }
       },
 
       'ArrowFunctionExpression:exit'() {
-        if (callStack[callStack.length - 1] === 'arrowFunc') {
+        if (callStack[callStack.length - 1] === 'arrow') {
           callStack.pop();
         }
       }

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

@@ -15,6 +15,8 @@ var _default = (0, _utils.createRule)({
       category: 'Best Practices',
       recommended: false
     },
+    deprecated: true,
+    replacedBy: ['no-conditional-expect'],
     messages: {
       noTryExpect: ['Tests should use Jest‘s exception helpers.', 'Use "expect(() => yourFunction()).toThrow()" for synchronous tests,', 'or "await expect(yourFunction()).rejects.toThrow()" for async tests'].join(' ')
     },

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

@@ -87,17 +87,21 @@ var _default = (0, _utils.createRule)({
         }
 
         if (!(0, _utils.hasOnlyOneArgument)(testFuncFirstLine)) {
-          const report = {
-            messageId: 'assertionsRequiresOneArgument',
-            loc: testFuncFirstLine.callee.property.loc
-          };
+          let {
+            loc
+          } = testFuncFirstLine.callee.property;
+          const suggest = [];
 
           if (testFuncFirstLine.arguments.length) {
-            report.loc = testFuncFirstLine.arguments[1].loc;
-            report.suggest = [suggestRemovingExtraArguments(testFuncFirstLine.arguments, 1)];
+            loc = testFuncFirstLine.arguments[1].loc;
+            suggest.push(suggestRemovingExtraArguments(testFuncFirstLine.arguments, 1));
           }
 
-          context.report(report);
+          context.report({
+            messageId: 'assertionsRequiresOneArgument',
+            suggest,
+            loc
+          });
           return;
         }
 

package/lib/rules/valid-title.js

@@ -52,8 +52,7 @@ var _default = (0, _utils.createRule)({
           type: 'array',
           items: {
             type: 'string'
-          },
-          default: []
+          }
         }
       },
       additionalProperties: false
@@ -67,7 +66,7 @@ var _default = (0, _utils.createRule)({
 
   create(context, [{
     ignoreTypeOfDescribeName,
-    disallowedWords
+    disallowedWords = []
   }]) {
     const disallowedWordsRegexp = new RegExp(`\\b(${disallowedWords.join('|')})\\b`, 'iu');
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "23.14.0",
+  "version": "23.17.1",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -53,6 +53,8 @@
     ]
   },
   "prettier": {
+    "arrowParens": "avoid",
+    "endOfLine": "auto",
     "proseWrap": "always",
     "singleQuote": true,
     "trailingComma": "all"
@@ -100,9 +102,9 @@
     "@semantic-release/changelog": "^3.0.5",
     "@semantic-release/git": "^7.0.17",
     "@types/dedent": "^0.7.0",
-    "@types/eslint": "^6.1.3",
     "@types/jest": "^25.1.0",
     "@types/node": "^12.6.6",
+    "@types/prettier": "^1.19.0",
     "@typescript-eslint/eslint-plugin": "^2.5.0",
     "@typescript-eslint/parser": "^2.5.0",
     "babel-jest": "^25.2.0",
@@ -118,7 +120,7 @@
     "eslint-plugin-prettier": "^3.0.0",
     "husky": "^3.0.9",
     "jest": "^25.2.0",
-    "jest-runner-eslint": "^0.8.0",
+    "jest-runner-eslint": "^0.9.0",
     "lint-staged": "^9.4.2",
     "prettier": "^1.19.1",
     "prettylint": "^1.0.0",