eslint-plugin-jest 24.4.2 → 26.1.0

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

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const getBlockType = statement => {
   const func = statement.parent;
@@ -18,19 +18,19 @@ const getBlockType = statement => {
   } // functionDeclaration: function func() {}
 
 
-  if (func.type === _experimentalUtils.AST_NODE_TYPES.FunctionDeclaration) {
+  if (func.type === _utils.AST_NODE_TYPES.FunctionDeclaration) {
     return 'function';
   }
 
-  if ((0, _utils.isFunction)(func) && func.parent) {
+  if ((0, _utils2.isFunction)(func) && func.parent) {
     const expr = func.parent; // arrow function or function expr
 
-    if (expr.type === _experimentalUtils.AST_NODE_TYPES.VariableDeclarator) {
+    if (expr.type === _utils.AST_NODE_TYPES.VariableDeclarator) {
       return 'function';
     } // if it's not a variable, it will be callExpr, we only care about describe
 
 
-    if (expr.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isDescribeCall)(expr)) {
+    if (expr.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isDescribeCall)(expr)) {
       return 'describe';
     }
   }
@@ -38,7 +38,7 @@ const getBlockType = statement => {
   return null;
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -71,16 +71,16 @@ var _default = (0, _utils.createRule)({
   }]) {
     const callStack = [];
 
-    const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils.getNodeName)(node) || '');
+    const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils2.getNodeName)(node) || '');
 
-    const isTestBlock = node => (0, _utils.isTestCaseCall)(node) || isCustomTestBlockFunction(node);
+    const isTestBlock = node => (0, _utils2.isTestCaseCall)(node) || isCustomTestBlockFunction(node);
 
     return {
       CallExpression(node) {
-        if ((0, _utils.isExpectCall)(node)) {
+        if ((0, _utils2.isExpectCall)(node)) {
           const parent = callStack[callStack.length - 1];
 
-          if (!parent || parent === _utils.DescribeAlias.describe) {
+          if (!parent || parent === _utils2.DescribeAlias.describe) {
             context.report({
               node,
               messageId: 'unexpectedExpect'
@@ -94,7 +94,7 @@ var _default = (0, _utils.createRule)({
           callStack.push('test');
         }
 
-        if (node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.push('template');
         }
       },
@@ -102,7 +102,7 @@ var _default = (0, _utils.createRule)({
       'CallExpression:exit'(node) {
         const top = callStack[callStack.length - 1];
 
-        if (top === 'test' && isTestBlock(node) && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (top === 'test' && isTestBlock(node) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.pop();
         }
       },
@@ -124,7 +124,7 @@ var _default = (0, _utils.createRule)({
       ArrowFunctionExpression(node) {
         var _node$parent;
 
-        if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+        if (((_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
           callStack.push('arrow');
         }
       },

package/lib/rules/no-test-prefixes.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -29,11 +29,11 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        const nodeName = (0, _utils.getNodeName)(node.callee);
-        if (!nodeName || !(0, _utils.isDescribeCall)(node) && !(0, _utils.isTestCaseCall)(node)) return;
+        const nodeName = (0, _utils2.getNodeName)(node.callee);
+        if (!nodeName || !(0, _utils2.isDescribeCall)(node) && !(0, _utils2.isTestCaseCall)(node)) return;
         const preferredNodeName = getPreferredNodeName(nodeName);
         if (!preferredNodeName) return;
-        const funcNode = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+        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;
         context.report({
           messageId: 'usePreferredName',
           node: node.callee,

package/lib/rules/no-test-return-statement.js

@@ -5,21 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const getBody = args => {
   const [, secondArg] = args;
 
-  if (secondArg && (0, _utils.isFunction)(secondArg) && secondArg.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+  if (secondArg && (0, _utils2.isFunction)(secondArg) && secondArg.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
     return secondArg.body.body;
   }
 
   return [];
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -38,9 +38,9 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isTestCaseCall)(node)) return;
+        if (!(0, _utils2.isTestCaseCall)(node)) return;
         const body = getBody(node.arguments);
-        const returnStmt = body.find(t => t.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement);
+        const returnStmt = body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;
         context.report({
           messageId: 'noReturnValue',
@@ -50,9 +50,9 @@ var _default = (0, _utils.createRule)({
 
       FunctionDeclaration(node) {
         const declaredVariables = context.getDeclaredVariables(node);
-        const testCallExpressions = (0, _utils.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
+        const testCallExpressions = (0, _utils2.getTestCallExpressionsFromDeclaredVariables)(declaredVariables);
         if (testCallExpressions.length === 0) return;
-        const returnStmt = node.body.body.find(t => t.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement);
+        const returnStmt = node.body.body.find(t => t.type === _utils.AST_NODE_TYPES.ReturnStatement);
         if (!returnStmt) return;
         context.report({
           messageId: 'noReturnValue',

package/lib/rules/prefer-comparison-matcher.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+
+/**
+ * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
+ * with a boolean literal as the sole argument.
+ *
+ * @example javascript
+ * toBe(true);
+ * toEqual(false);
+ *
+ * @param {ParsedExpectMatcher} matcher
+ *
+ * @return {matcher is ParsedBooleanEqualityMatcher}
+ */
+const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
+
+const isString = node => {
+  return (0, _utils2.isStringNode)(node) || node.type === _utils.AST_NODE_TYPES.TemplateLiteral;
+};
+
+const isComparingToString = expression => {
+  return isString(expression.left) || isString(expression.right);
+};
+
+const invertOperator = operator => {
+  switch (operator) {
+    case '>':
+      return '<=';
+
+    case '<':
+      return '>=';
+
+    case '>=':
+      return '<';
+
+    case '<=':
+      return '>';
+  }
+
+  return null;
+};
+
+const determineMatcher = (operator, negated) => {
+  const op = negated ? invertOperator(operator) : operator;
+
+  switch (op) {
+    case '>':
+      return 'toBeGreaterThan';
+
+    case '<':
+      return 'toBeLessThan';
+
+    case '>=':
+      return 'toBeGreaterThanOrEqual';
+
+    case '<=':
+      return 'toBeLessThanOrEqual';
+  }
+
+  return null;
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Suggest using the built-in comparison matchers',
+      recommended: false
+    },
+    messages: {
+      useToBeComparison: 'Prefer using `{{ preferredMatcher }}` instead'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!(0, _utils2.isExpectCall)(node)) {
+          return;
+        }
+
+        const {
+          expect: {
+            arguments: [comparison],
+            range: [, expectCallEnd]
+          },
+          matcher,
+          modifier
+        } = (0, _utils2.parseExpectCall)(node);
+
+        if (!matcher || (comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !isBooleanEqualityMatcher(matcher)) {
+          return;
+        }
+
+        const preferredMatcher = determineMatcher(comparison.operator, (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!modifier);
+
+        if (!preferredMatcher) {
+          return;
+        }
+
+        context.report({
+          fix(fixer) {
+            const sourceCode = context.getSourceCode();
+            return [// replace the comparison argument with the left-hand side of the comparison
+            fixer.replaceText(comparison, sourceCode.getText(comparison.left)), // replace the current matcher & modifier with the preferred matcher
+            fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], `.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+            fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
+          },
+
+          messageId: 'useToBeComparison',
+          data: {
+            preferredMatcher
+          },
+          node: (modifier || matcher).node.property
+        });
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-equality-matcher.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 isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+
+/**
+ * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
+ * with a boolean literal as the sole argument.
+ *
+ * @example javascript
+ * toBe(true);
+ * toEqual(false);
+ *
+ * @param {ParsedExpectMatcher} matcher
+ *
+ * @return {matcher is ParsedBooleanEqualityMatcher}
+ */
+const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Suggest using the built-in equality matchers',
+      recommended: false,
+      suggestion: true
+    },
+    messages: {
+      useEqualityMatcher: 'Prefer using one of the equality matchers instead',
+      suggestEqualityMatcher: 'Use `{{ equalityMatcher }}`'
+    },
+    hasSuggestions: true,
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!(0, _utils2.isExpectCall)(node)) {
+          return;
+        }
+
+        const {
+          expect: {
+            arguments: [comparison],
+            range: [, expectCallEnd]
+          },
+          matcher,
+          modifier
+        } = (0, _utils2.parseExpectCall)(node);
+
+        if (!matcher || (comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== '===' && comparison.operator !== '!==' || !isBooleanEqualityMatcher(matcher)) {
+          return;
+        }
+
+        const matcherValue = (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value; // we need to negate the expectation if the current expected
+        // value is itself negated by the "not" modifier
+
+        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === !!modifier;
+
+        const buildFixer = equalityMatcher => fixer => {
+          const sourceCode = context.getSourceCode();
+          return [// replace the comparison argument with the left-hand side of the comparison
+          fixer.replaceText(comparison, sourceCode.getText(comparison.left)), // replace the current matcher & modifier with the preferred matcher
+          fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], addNotModifier ? `.${_utils2.ModifierName.not}.${equalityMatcher}` : `.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+          fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
+        };
+
+        context.report({
+          messageId: 'useEqualityMatcher',
+          suggest: ['toBe', 'toEqual', 'toStrictEqual'].map(equalityMatcher => ({
+            messageId: 'suggestEqualityMatcher',
+            data: {
+              equalityMatcher
+            },
+            fix: buildFixer(equalityMatcher)
+          })),
+          node: (modifier || matcher).node.property
+        });
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

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

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
-const isExpectAssertionsOrHasAssertionsCall = expression => expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && expression.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(expression.callee.object, 'expect') && (0, _utils.isSupportedAccessor)(expression.callee.property) && ['assertions', 'hasAssertions'].includes((0, _utils.getAccessorValue)(expression.callee.property));
+const isExpectAssertionsOrHasAssertionsCall = expression => expression.type === _utils.AST_NODE_TYPES.CallExpression && expression.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(expression.callee.object, 'expect') && (0, _utils2.isSupportedAccessor)(expression.callee.property) && ['assertions', 'hasAssertions'].includes((0, _utils2.getAccessorValue)(expression.callee.property));
 
-const isFirstLineExprStmt = functionBody => functionBody[0] && functionBody[0].type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement;
+const isFirstLineExprStmt = functionBody => functionBody[0] && functionBody[0].type === _utils.AST_NODE_TYPES.ExpressionStatement;
 
 const suggestRemovingExtraArguments = (args, extraArgsStartAt) => ({
   messageId: 'suggestRemovingExtraArguments',
@@ -20,7 +20,7 @@ const suggestRemovingExtraArguments = (args, extraArgsStartAt) => ({
 
 const suggestions = [['suggestAddingHasAssertions', 'expect.hasAssertions();'], ['suggestAddingAssertions', 'expect.assertions();']];
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -45,19 +45,95 @@ var _default = (0, _utils.createRule)({
       properties: {
         onlyFunctionsWithAsyncKeyword: {
           type: 'boolean'
+        },
+        onlyFunctionsWithExpectInLoop: {
+          type: 'boolean'
+        },
+        onlyFunctionsWithExpectInCallback: {
+          type: 'boolean'
         }
       },
       additionalProperties: false
     }]
   },
   defaultOptions: [{
-    onlyFunctionsWithAsyncKeyword: false
+    onlyFunctionsWithAsyncKeyword: 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 && !options.onlyFunctionsWithExpectInCallback) {
+        return true;
+      }
+
+      if (options.onlyFunctionsWithAsyncKeyword) {
+        if (testFunction.async) {
+          return true;
+        }
+      }
+
+      if (options.onlyFunctionsWithExpectInLoop) {
+        if (hasExpectInLoop) {
+          return true;
+        }
+      }
+
+      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,
+      'ForInStatement:exit': exitForLoop,
+      ForOfStatement: enterForLoop,
+      'ForOfStatement:exit': exitForLoop,
+
       CallExpression(node) {
-        if (!(0, _utils.isTestCaseCall)(node)) {
+        if ((0, _utils2.isTestCaseCall)(node)) {
+          inTestCaseCall = true;
+          return;
+        }
+
+        if ((0, _utils2.isExpectCall)(node) && inTestCaseCall) {
+          if (inForLoop) {
+            hasExpectInLoop = true;
+          }
+
+          if (expressionDepth > 1) {
+            hasExpectInCallback = true;
+          }
+        }
+      },
+
+      'CallExpression:exit'(node) {
+        if (!(0, _utils2.isTestCaseCall)(node)) {
           return;
         }
 
@@ -67,10 +143,16 @@ 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, _utils2.isFunction)(testFn) || testFn.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+          return;
+        }
+
+        if (!shouldCheckFunction(testFn)) {
           return;
         }
 
+        hasExpectInLoop = false;
+        hasExpectInCallback = false;
         const testFuncBody = testFn.body.body;
 
         if (!isFirstLineExprStmt(testFuncBody)) {
@@ -99,7 +181,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if ((0, _utils.isSupportedAccessor)(testFuncFirstLine.callee.property, 'hasAssertions')) {
+        if ((0, _utils2.isSupportedAccessor)(testFuncFirstLine.callee.property, 'hasAssertions')) {
           if (testFuncFirstLine.arguments.length) {
             context.report({
               messageId: 'hasAssertionsTakesNoArguments',
@@ -111,7 +193,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (!(0, _utils.hasOnlyOneArgument)(testFuncFirstLine)) {
+        if (!(0, _utils2.hasOnlyOneArgument)(testFuncFirstLine)) {
           let {
             loc
           } = testFuncFirstLine.callee.property;
@@ -132,7 +214,7 @@ var _default = (0, _utils.createRule)({
 
         const [arg] = testFuncFirstLine.arguments;
 
-        if (arg.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof arg.value === 'number' && Number.isInteger(arg.value)) {
+        if (arg.type === _utils.AST_NODE_TYPES.Literal && typeof arg.value === 'number' && Number.isInteger(arg.value)) {
           return;
         }
 

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer `await expect(...).resolves` over `expect(await ...)` syntax',
+      recommended: false
+    },
+    fixable: 'code',
+    messages: {
+      expectResolves: 'Use `await expect(...).resolves instead.'
+    },
+    schema: [],
+    type: 'suggestion'
+  },
+  defaultOptions: [],
+  create: context => ({
+    CallExpression(node) {
+      const [awaitNode] = node.arguments;
+
+      if ((0, _utils2.isExpectCall)(node) && (awaitNode === null || awaitNode === void 0 ? void 0 : awaitNode.type) === _utils.AST_NODE_TYPES.AwaitExpression) {
+        context.report({
+          node: node.arguments[0],
+          messageId: 'expectResolves',
+
+          fix(fixer) {
+            return [fixer.insertTextBefore(node, 'await '), fixer.removeRange([awaitNode.range[0], awaitNode.argument.range[0]]), fixer.insertTextAfter(node, '.resolves')];
+          }
+
+        });
+      }
+    }
+
+  })
+});
+
+exports.default = _default;

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/{lowercase-name.js → prefer-lowercase-title.js}

@@ -21,6 +21,24 @@ const findNodeNameAndArgument = node => {
   return [(0, _utils.getNodeName)(node).split('.')[0], node.arguments[0]];
 };
 
+const populateIgnores = ignore => {
+  const ignores = [];
+
+  if (ignore.includes(_utils.DescribeAlias.describe)) {
+    ignores.push(...Object.keys(_utils.DescribeAlias));
+  }
+
+  if (ignore.includes(_utils.TestCaseName.test)) {
+    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).filter(k => k.endsWith(_utils.TestCaseName.it)));
+  }
+
+  return ignores;
+};
+
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -70,6 +88,7 @@ var _default = (0, _utils.createRule)({
     allowedPrefixes = [],
     ignoreTopLevelDescribe
   }]) {
+    const ignores = populateIgnores(ignore);
     let numberOfDescribeBlocks = 0;
     return {
       CallExpression(node) {
@@ -96,7 +115,7 @@ var _default = (0, _utils.createRule)({
 
         const firstCharacter = description.charAt(0);
 
-        if (!firstCharacter || firstCharacter === firstCharacter.toLowerCase() || ignore.includes(name)) {
+        if (!firstCharacter || firstCharacter === firstCharacter.toLowerCase() || ignores.includes(name)) {
           return;
         }