eslint-plugin-jest 25.7.0 → 26.0.0

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
@@ -33,10 +33,10 @@ const isBooleanEqualityMatcher = matcher => (0, _utils.isParsedEqualityMatcherCa
  *
  * @return {node is FixableIncludesCallExpression}
  */
-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>)
+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>)
 
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -56,7 +56,7 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
@@ -67,9 +67,9 @@ var _default = (0, _utils.createRule)({
           },
           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;
         }
 
@@ -78,10 +78,10 @@ var _default = (0, _utils.createRule)({
             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;
+            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 ? `.${_utils.ModifierName.not}.toContain` : '.toContain'), // replace the matcher argument with the value from the "includes"
+            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]))];
           },
 

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,9 +38,9 @@ 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')) {
+        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;
         }
 

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

@@ -5,33 +5,33 @@ 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 isJestFnCall = node => {
   var _getNodeName;
 
-  if ((0, _utils.isDescribeCall)(node) || (0, _utils.isTestCaseCall)(node) || (0, _utils.isHook)(node)) {
+  if ((0, _utils2.isDescribeCall)(node) || (0, _utils2.isTestCaseCall)(node) || (0, _utils2.isHook)(node)) {
     return true;
   }
 
-  return !!((_getNodeName = (0, _utils.getNodeName)(node)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith('jest.'));
+  return !!((_getNodeName = (0, _utils2.getNodeName)(node)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith('jest.'));
 };
 
 const isNullOrUndefined = node => {
-  return node.type === _experimentalUtils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils.isIdentifier)(node, 'undefined');
+  return node.type === _utils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils2.isIdentifier)(node, 'undefined');
 };
 
 const shouldBeInHook = (node, allowedFunctionCalls = []) => {
   switch (node.type) {
-    case _experimentalUtils.AST_NODE_TYPES.ExpressionStatement:
+    case _utils.AST_NODE_TYPES.ExpressionStatement:
       return shouldBeInHook(node.expression, allowedFunctionCalls);
 
-    case _experimentalUtils.AST_NODE_TYPES.CallExpression:
-      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils.getNodeName)(node)));
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
 
-    case _experimentalUtils.AST_NODE_TYPES.VariableDeclaration:
+    case _utils.AST_NODE_TYPES.VariableDeclaration:
       {
         if (node.kind === 'const') {
           return false;
@@ -47,7 +47,7 @@ const shouldBeInHook = (node, allowedFunctionCalls = []) => {
   }
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -100,13 +100,13 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
-        if (!(0, _utils.isDescribeCall)(node) || node.arguments.length < 2) {
+        if (!(0, _utils2.isDescribeCall)(node) || node.arguments.length < 2) {
           return;
         }
 
         const [, testFn] = node.arguments;
 
-        if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+        if (!(0, _utils2.isFunction)(testFn) || testFn.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
           return;
         }
 

package/lib/rules/utils.js

@@ -9,20 +9,20 @@ exports.scopeHasLocalReference = exports.parseExpectCall = exports.isTestCaseCal
 
 var _path = require("path");
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
 var _package = require("../../package.json");
 
 const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
 
-const createRule = _experimentalUtils.ESLintUtils.RuleCreator(name => {
+const createRule = _utils.ESLintUtils.RuleCreator(name => {
   const ruleName = (0, _path.parse)(name).name;
   return `${REPO_URL}/blob/v${_package.version}/docs/rules/${ruleName}.md`;
 });
 
 exports.createRule = createRule;
 
-const isTypeCastExpression = node => node.type === _experimentalUtils.AST_NODE_TYPES.TSAsExpression || node.type === _experimentalUtils.AST_NODE_TYPES.TSTypeAssertion;
+const isTypeCastExpression = node => node.type === _utils.AST_NODE_TYPES.TSAsExpression || node.type === _utils.AST_NODE_TYPES.TSTypeAssertion;
 
 const followTypeAssertionChain = expression => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
 /**
@@ -45,7 +45,7 @@ exports.followTypeAssertionChain = followTypeAssertionChain;
  *
  * @template V
  */
-const isStringLiteral = (node, value) => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
+const isStringLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
 
 /**
  * Checks if the given `node` is a `TemplateLiteral`.
@@ -62,7 +62,7 @@ const isStringLiteral = (node, value) => node.type === _experimentalUtils.AST_NO
  *
  * @template V
  */
-const isTemplateLiteral = (node, value) => node.type === _experimentalUtils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
+const isTemplateLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
 value === undefined || node.quasis[0].value.raw === value);
 
 /**
@@ -128,7 +128,7 @@ exports.hasOnlyOneArgument = hasOnlyOneArgument;
  *
  * @template V
  */
-const isIdentifier = (node, name) => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
+const isIdentifier = (node, name) => node.type === _utils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
 /**
  * Checks if the given `node` is a "supported accessor".
  *
@@ -170,7 +170,7 @@ const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStri
 
 exports.isSupportedAccessor = isSupportedAccessor;
 
-const getAccessorValue = accessor => accessor.type === _experimentalUtils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
+const getAccessorValue = accessor => accessor.type === _utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
 
 exports.getAccessorValue = getAccessorValue;
 
@@ -186,11 +186,11 @@ exports.getAccessorValue = getAccessorValue;
  *
  * @return {node is ExpectCall}
  */
-const isExpectCall = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && isSupportedAccessor(node.callee, 'expect') && node.parent !== undefined;
+const isExpectCall = node => node.type === _utils.AST_NODE_TYPES.CallExpression && isSupportedAccessor(node.callee, 'expect') && node.parent !== undefined;
 
 exports.isExpectCall = isExpectCall;
 
-const isExpectMember = (node, name) => node.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.property, name);
+const isExpectMember = (node, name) => node.type === _utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.property, name);
 /**
  * Represents all the jest matchers.
  */
@@ -235,7 +235,7 @@ const reparseAsMatcher = parsedMember => ({ ...parsedMember,
    *
    * If this matcher isn't called, this will be `null`.
    */
-  arguments: parsedMember.node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
+  arguments: parsedMember.node.parent.type === _utils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
 });
 /**
  * Re-parses the given `parsedMember` as a `ParsedExpectModifier`.
@@ -366,25 +366,25 @@ function getNodeName(node) {
   }
 
   switch (node.type) {
-    case _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression:
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
       return getNodeName(node.tag);
 
-    case _experimentalUtils.AST_NODE_TYPES.MemberExpression:
+    case _utils.AST_NODE_TYPES.MemberExpression:
       return joinNames(getNodeName(node.object), getNodeName(node.property));
 
-    case _experimentalUtils.AST_NODE_TYPES.NewExpression:
-    case _experimentalUtils.AST_NODE_TYPES.CallExpression:
+    case _utils.AST_NODE_TYPES.NewExpression:
+    case _utils.AST_NODE_TYPES.CallExpression:
       return getNodeName(node.callee);
   }
 
   return null;
 }
 
-const isFunction = node => node.type === _experimentalUtils.AST_NODE_TYPES.FunctionExpression || node.type === _experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression;
+const isFunction = node => node.type === _utils.AST_NODE_TYPES.FunctionExpression || node.type === _utils.AST_NODE_TYPES.ArrowFunctionExpression;
 
 exports.isFunction = isFunction;
 
-const isHook = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && HookName.hasOwnProperty(node.callee.name);
+const isHook = node => node.callee.type === _utils.AST_NODE_TYPES.Identifier && HookName.hasOwnProperty(node.callee.name);
 
 exports.isHook = isHook;
 
@@ -393,12 +393,12 @@ const getTestCallExpressionsFromDeclaredVariables = declaredVariables => {
     references
   }) => acc.concat(references.map(({
     identifier
-  }) => identifier.parent).filter(node => !!node && node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && isTestCaseCall(node))), []);
+  }) => identifier.parent).filter(node => !!node && node.type === _utils.AST_NODE_TYPES.CallExpression && isTestCaseCall(node))), []);
 };
 
 exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;
 
-const isTestCaseName = node => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && TestCaseName.hasOwnProperty(node.name);
+const isTestCaseName = node => node.type === _utils.AST_NODE_TYPES.Identifier && TestCaseName.hasOwnProperty(node.name);
 
 const isTestCaseProperty = node => isSupportedAccessor(node) && TestCaseProperty.hasOwnProperty(getAccessorValue(node));
 /**
@@ -419,15 +419,15 @@ const isTestCaseCall = node => {
     return true;
   }
 
-  const callee = 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 callee = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-  if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isTestCaseProperty(callee.property)) {
+  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isTestCaseProperty(callee.property)) {
     // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
-    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _utils.AST_NODE_TYPES.CallExpression) {
       return false;
     }
 
-    return callee.object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression ? isTestCaseName(callee.object.object) : isTestCaseName(callee.object);
+    return callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? isTestCaseName(callee.object.object) : isTestCaseName(callee.object);
   }
 
   return false;
@@ -435,7 +435,7 @@ const isTestCaseCall = node => {
 
 exports.isTestCaseCall = isTestCaseCall;
 
-const isDescribeAlias = node => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.name);
+const isDescribeAlias = node => node.type === _utils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.name);
 
 const isDescribeProperty = node => isSupportedAccessor(node) && DescribeProperty.hasOwnProperty(getAccessorValue(node));
 /**
@@ -456,15 +456,15 @@ const isDescribeCall = node => {
     return true;
   }
 
-  const callee = 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 callee = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-  if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isDescribeProperty(callee.property)) {
+  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isDescribeProperty(callee.property)) {
     // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
-    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _utils.AST_NODE_TYPES.CallExpression) {
       return false;
     }
 
-    return callee.object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression ? isDescribeAlias(callee.object.object) : isDescribeAlias(callee.object);
+    return callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? isDescribeAlias(callee.object.object) : isDescribeAlias(callee.object);
   }
 
   return false;

package/lib/rules/valid-describe-callback.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 paramsLocation = params => {
   const [first] = params;
@@ -18,7 +18,7 @@ const paramsLocation = params => {
   };
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     type: 'problem',
@@ -41,7 +41,7 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isDescribeCall)(node)) {
+        if (!(0, _utils2.isDescribeCall)(node)) {
           return;
         }
 
@@ -62,7 +62,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (!(0, _utils.isFunction)(callback)) {
+        if (!(0, _utils2.isFunction)(callback)) {
           context.report({
             messageId: 'secondArgumentMustBeFunction',
             loc: paramsLocation(node.arguments)
@@ -77,23 +77,23 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if (!(0, _utils.getNodeName)(node).endsWith('each') && callback.params.length) {
+        if (!(0, _utils2.getNodeName)(node).endsWith('each') && callback.params.length) {
           context.report({
             messageId: 'unexpectedDescribeArgument',
             loc: paramsLocation(callback.params)
           });
         }
 
-        if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+        if (callback.body.type === _utils.AST_NODE_TYPES.CallExpression) {
           context.report({
             messageId: 'unexpectedReturnInDescribe',
             node: callback
           });
         }
 
-        if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+        if (callback.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
           callback.body.body.forEach(node => {
-            if (node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+            if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
               context.report({
                 messageId: 'unexpectedReturnInDescribe',
                 node