eslint-plugin-jest 24.4.2 → 26.1.0

package/lib/rules/prefer-snapshot-hint.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("./utils");
+
+const snapshotMatchers = ['toMatchSnapshot', 'toThrowErrorMatchingSnapshot'];
+
+const isSnapshotMatcher = matcher => {
+  return snapshotMatchers.includes(matcher.name);
+};
+
+const isSnapshotMatcherWithoutHint = matcher => {
+  var _matcher$arguments;
+
+  const expectedNumberOfArgumentsWithHint = 1 + Number(matcher.name === 'toMatchSnapshot');
+  return ((_matcher$arguments = matcher.arguments) === null || _matcher$arguments === void 0 ? void 0 : _matcher$arguments.length) !== expectedNumberOfArgumentsWithHint;
+};
+
+const messages = {
+  missingHint: 'You should provide a hint for this snapshot'
+};
+
+var _default = (0, _utils.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prefer including a hint with external snapshots',
+      recommended: false
+    },
+    messages,
+    type: 'suggestion',
+    schema: [{
+      type: 'string',
+      enum: ['always', 'multi']
+    }]
+  },
+  defaultOptions: ['multi'],
+
+  create(context, [mode]) {
+    const snapshotMatchers = [];
+    let expressionDepth = 0;
+
+    const reportSnapshotMatchersWithoutHints = () => {
+      for (const snapshotMatcher of snapshotMatchers) {
+        if (isSnapshotMatcherWithoutHint(snapshotMatcher)) {
+          context.report({
+            messageId: 'missingHint',
+            node: snapshotMatcher.node.property
+          });
+        }
+      }
+    };
+
+    const enterExpression = () => {
+      expressionDepth++;
+    };
+
+    const exitExpression = () => {
+      expressionDepth--;
+
+      if (mode === 'always') {
+        reportSnapshotMatchersWithoutHints();
+        snapshotMatchers.length = 0;
+      }
+
+      if (mode === 'multi' && expressionDepth === 0) {
+        if (snapshotMatchers.length > 1) {
+          reportSnapshotMatchersWithoutHints();
+        }
+
+        snapshotMatchers.length = 0;
+      }
+    };
+
+    return {
+      'Program:exit'() {
+        enterExpression();
+        exitExpression();
+      },
+
+      FunctionExpression: enterExpression,
+      'FunctionExpression:exit': exitExpression,
+      ArrowFunctionExpression: enterExpression,
+      'ArrowFunctionExpression:exit': exitExpression,
+
+      CallExpression(node) {
+        if (!(0, _utils.isExpectCall)(node)) {
+          return;
+        }
+
+        const {
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
+
+        if (!matcher || !isSnapshotMatcher(matcher)) {
+          return;
+        }
+
+        snapshotMatchers.push(matcher);
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-spy-on.js

@@ -5,16 +5,16 @@ 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 findNodeObject = node => {
   if ('object' in node) {
     return node.object;
   }
 
-  if (node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+  if (node.callee.type === _utils.AST_NODE_TYPES.MemberExpression) {
     return node.callee.object;
   }
 
@@ -22,7 +22,7 @@ const findNodeObject = node => {
 };
 
 const getJestFnCall = node => {
-  if (node.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression && node.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+  if (node.type !== _utils.AST_NODE_TYPES.CallExpression && node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
     return null;
   }
 
@@ -32,14 +32,14 @@ const getJestFnCall = node => {
     return null;
   }
 
-  if (obj.type === _experimentalUtils.AST_NODE_TYPES.Identifier) {
-    return node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.getNodeName)(node.callee) === 'jest.fn' ? node : null;
+  if (obj.type === _utils.AST_NODE_TYPES.Identifier) {
+    return node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.getNodeName)(node.callee) === 'jest.fn' ? node : null;
   }
 
   return getJestFnCall(obj);
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -63,7 +63,7 @@ var _default = (0, _utils.createRule)({
           left,
           right
         } = node;
-        if (left.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) return;
+        if (left.type !== _utils.AST_NODE_TYPES.MemberExpression) return;
         const jestFnCall = getJestFnCall(right);
         if (!jestFnCall) return;
         context.report({
@@ -71,7 +71,7 @@ var _default = (0, _utils.createRule)({
           messageId: 'useJestSpyOn',
 
           fix(fixer) {
-            const leftPropQuote = left.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier ? "'" : '';
+            const leftPropQuote = left.property.type === _utils.AST_NODE_TYPES.Identifier ? "'" : '';
             const [arg] = jestFnCall.arguments;
             const argSource = arg && context.getSourceCode().getText(arg);
             const mockImplementation = argSource ? `.mockImplementation(${argSource})` : '.mockImplementation()';

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

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+const isNullLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && node.value === null;
+/**
+ * Checks if the given `ParsedEqualityMatcherCall` is a call to one of the equality matchers,
+ * with a `null` literal as the sole argument.
+ */
+
+
+const isNullEqualityMatcher = matcher => isNullLiteral(getFirstArgument(matcher));
+
+const isFirstArgumentIdentifier = (matcher, name) => (0, _utils2.isIdentifier)(getFirstArgument(matcher), name);
+
+const shouldUseToBe = matcher => {
+  const firstArg = getFirstArgument(matcher);
+
+  if (firstArg.type === _utils.AST_NODE_TYPES.Literal) {
+    // regex literals are classed as literals, but they're actually objects
+    // which means "toBe" will give different results than other matchers
+    return !('regex' in firstArg);
+  }
+
+  return firstArg.type === _utils.AST_NODE_TYPES.TemplateLiteral;
+};
+
+const getFirstArgument = matcher => {
+  return (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]);
+};
+
+const reportPreferToBe = (context, whatToBe, matcher, modifier) => {
+  const modifierNode = (modifier === null || modifier === void 0 ? void 0 : modifier.negation) || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not && (modifier === null || modifier === void 0 ? void 0 : modifier.node);
+  context.report({
+    messageId: `useToBe${whatToBe}`,
+
+    fix(fixer) {
+      var _matcher$arguments;
+
+      const fixes = [fixer.replaceText(matcher.node.property, `toBe${whatToBe}`)];
+
+      if ((_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length && whatToBe !== '') {
+        fixes.push(fixer.remove(matcher.arguments[0]));
+      }
+
+      if (modifierNode) {
+        fixes.push(fixer.removeRange([modifierNode.property.range[0] - 1, modifierNode.property.range[1]]));
+      }
+
+      return fixes;
+    },
+
+    node: matcher.node.property
+  });
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Suggest using `toBe()` for primitive literals',
+      recommended: false
+    },
+    messages: {
+      useToBe: 'Use `toBe` when expecting primitive literals',
+      useToBeUndefined: 'Use `toBeUndefined` instead',
+      useToBeDefined: 'Use `toBeDefined` instead',
+      useToBeNull: 'Use `toBeNull` instead',
+      useToBeNaN: 'Use `toBeNaN` instead'
+    },
+    fixable: 'code',
+    type: 'suggestion',
+    schema: []
+  },
+  defaultOptions: [],
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!(0, _utils2.isExpectCall)(node)) {
+          return;
+        }
+
+        const {
+          matcher,
+          modifier
+        } = (0, _utils2.parseExpectCall)(node);
+
+        if (!matcher) {
+          return;
+        }
+
+        if (((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation) && ['toBeUndefined', 'toBeDefined'].includes(matcher.name)) {
+          reportPreferToBe(context, matcher.name === 'toBeDefined' ? 'Undefined' : 'Defined', matcher, modifier);
+          return;
+        }
+
+        if (!(0, _utils2.isParsedEqualityMatcherCall)(matcher)) {
+          return;
+        }
+
+        if (isNullEqualityMatcher(matcher)) {
+          reportPreferToBe(context, 'Null', matcher);
+          return;
+        }
+
+        if (isFirstArgumentIdentifier(matcher, 'undefined')) {
+          const name = (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation ? 'Defined' : 'Undefined';
+          reportPreferToBe(context, name, matcher, modifier);
+          return;
+        }
+
+        if (isFirstArgumentIdentifier(matcher, 'NaN')) {
+          reportPreferToBe(context, 'NaN', matcher);
+          return;
+        }
+
+        if (shouldUseToBe(matcher) && matcher.name !== _utils2.EqualityMatcher.toBe) {
+          reportPreferToBe(context, '', matcher);
+        }
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;

package/lib/rules/prefer-to-contain.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");
 
-const isBooleanLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+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,
@@ -23,7 +23,7 @@ const isBooleanLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES
  *
  * @return {matcher is ParsedBooleanEqualityMatcher}
  */
-const isBooleanEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils.followTypeAssertionChain)(matcher.arguments[0]));
+const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
 
 /**
  * Checks if the given `node` is a `CallExpression` representing the calling
@@ -32,55 +32,11 @@ 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 isFixableIncludesCallExpression = node => node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property, 'includes') && (0, _utils2.hasOnlyOneArgument)(node); // expect(array.includes(<value>)[not.]{toBe,toEqual}(<boolean>)
 
 
-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>)
-
-
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -100,37 +56,33 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
         const {
           expect: {
-            arguments: [includesCall]
+            arguments: [includesCall],
+            range: [, expectCallEnd]
           },
           matcher,
           modifier
-        } = (0, _utils.parseExpectCall)(node);
+        } = (0, _utils2.parseExpectCall)(node);
 
-        if (!matcher || !includesCall || modifier && modifier.name !== _utils.ModifierName.not || !isBooleanEqualityMatcher(matcher) || !isFixableIncludesCallExpression(includesCall)) {
+        if (!matcher || !includesCall || modifier && modifier.name !== _utils2.ModifierName.not || !isBooleanEqualityMatcher(matcher) || !isFixableIncludesCallExpression(includesCall)) {
           return;
         }
 
         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, _utils2.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 ? `.${_utils2.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

@@ -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,7 +29,7 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
@@ -38,22 +38,17 @@ var _default = (0, _utils.createRule)({
             arguments: [argument]
           },
           matcher
-        } = (0, _utils.parseExpectCall)(node);
+        } = (0, _utils2.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, _utils2.isParsedEqualityMatcherCall)(matcher) || (argument === null || argument === void 0 ? void 0 : argument.type) !== _utils.AST_NODE_TYPES.MemberExpression || !(0, _utils2.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/lib/rules/prefer-todo.js

@@ -5,26 +5,26 @@ 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");
 
 function isEmptyFunction(node) {
-  if (!(0, _utils.isFunction)(node)) {
+  if (!(0, _utils2.isFunction)(node)) {
     return false;
   }
 
-  return node.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
+  return node.body.type === _utils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
 }
 
 function createTodoFixer(node, fixer) {
-  const testName = (0, _utils.getNodeName)(node).split('.').shift();
+  const testName = (0, _utils2.getNodeName)(node).split('.').shift();
   return fixer.replaceText(node.callee, `${testName}.todo`);
 }
 
-const isTargetedTestCase = node => (0, _utils.isTestCaseCall)(node) && [_utils.TestCaseName.it, _utils.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils.getNodeName)(node));
+const isTargetedTestCase = node => (0, _utils2.isTestCaseCall)(node) && [_utils2.TestCaseName.it, _utils2.TestCaseName.test, 'it.skip', 'test.skip'].includes((0, _utils2.getNodeName)(node));
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -47,7 +47,7 @@ var _default = (0, _utils.createRule)({
       CallExpression(node) {
         const [title, callback] = node.arguments;
 
-        if (!title || !isTargetedTestCase(node) || !(0, _utils.isStringNode)(title)) {
+        if (!title || !isTargetedTestCase(node) || !(0, _utils2.isStringNode)(title)) {
           return;
         }
 
@@ -59,7 +59,7 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if ((0, _utils.hasOnlyOneArgument)(node)) {
+        if ((0, _utils2.hasOnlyOneArgument)(node)) {
           context.report({
             messageId: 'unimplementedTest',
             node,

package/lib/rules/require-hook.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("@typescript-eslint/utils");
+
+var _utils2 = require("./utils");
+
+const isJestFnCall = node => {
+  var _getNodeName;
+
+  if ((0, _utils2.isDescribeCall)(node) || (0, _utils2.isTestCaseCall)(node) || (0, _utils2.isHook)(node)) {
+    return true;
+  }
+
+  return !!((_getNodeName = (0, _utils2.getNodeName)(node)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith('jest.'));
+};
+
+const isNullOrUndefined = node => {
+  return node.type === _utils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils2.isIdentifier)(node, 'undefined');
+};
+
+const shouldBeInHook = (node, allowedFunctionCalls = []) => {
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.ExpressionStatement:
+      return shouldBeInHook(node.expression, allowedFunctionCalls);
+
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
+
+    case _utils.AST_NODE_TYPES.VariableDeclaration:
+      {
+        if (node.kind === 'const') {
+          return false;
+        }
+
+        return node.declarations.some(({
+          init
+        }) => init !== null && !isNullOrUndefined(init));
+      }
+
+    default:
+      return false;
+  }
+};
+
+var _default = (0, _utils2.createRule)({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Require setup and teardown code to be within a hook',
+      recommended: false
+    },
+    messages: {
+      useHook: 'This should be done within a hook'
+    },
+    type: 'suggestion',
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedFunctionCalls: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  defaultOptions: [{
+    allowedFunctionCalls: []
+  }],
+
+  create(context) {
+    var _context$options$;
+
+    const {
+      allowedFunctionCalls
+    } = (_context$options$ = context.options[0]) !== null && _context$options$ !== void 0 ? _context$options$ : {};
+
+    const checkBlockBody = body => {
+      for (const statement of body) {
+        if (shouldBeInHook(statement, allowedFunctionCalls)) {
+          context.report({
+            node: statement,
+            messageId: 'useHook'
+          });
+        }
+      }
+    };
+
+    return {
+      Program(program) {
+        checkBlockBody(program.body);
+      },
+
+      CallExpression(node) {
+        if (!(0, _utils2.isDescribeCall)(node) || node.arguments.length < 2) {
+          return;
+        }
+
+        const [, testFn] = node.arguments;
+
+        if (!(0, _utils2.isFunction)(testFn) || testFn.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
+          return;
+        }
+
+        checkBlockBody(testFn.body.body);
+      }
+
+    };
+  }
+
+});
+
+exports.default = _default;