eslint-plugin-jest 22.21.0 → 23.0.3

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

@@ -7,14 +7,6 @@ exports.default = void 0;
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -24,7 +16,8 @@ var _default = (0, _utils.createRule)({
       recommended: false
     },
     messages: {
-      illegalTestCallback: 'Illegal usage of test callback'
+      illegalTestCallback: 'Illegal usage of test callback',
+      useAwaitInsteadOfCallback: 'Use await instead of callback in async functions'
     },
     fixable: 'code',
     schema: [],
@@ -39,22 +32,30 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _node$arguments = _slicedToArray(node.arguments, 2),
-              callback = _node$arguments[1];
+        const [, callback] = node.arguments;
 
         if (!(0, _utils.isFunction)(callback) || callback.params.length !== 1) {
           return;
         }
 
-        const _callback$params = _slicedToArray(callback.params, 1),
-              argument = _callback$params[0];
+        const [argument] = callback.params;
+
+        if (callback.async) {
+          context.report({
+            node: argument,
+            messageId: 'useAwaitInsteadOfCallback'
+          });
+          return;
+        }
 
         context.report({
           node: argument,
           messageId: 'illegalTestCallback',
 
           fix(fixer) {
-            const body = callback.body;
+            const {
+              body
+            } = callback;
             /* istanbul ignore if https://github.com/typescript-eslint/typescript-eslint/issues/734 */
 
             if (!body) {
@@ -90,7 +91,7 @@ var _default = (0, _utils.createRule)({
             let replaceBefore = true;
 
             if (body.type === 'BlockStatement') {
-              const keyword = callback.async ? 'await' : 'return';
+              const keyword = 'return';
               beforeReplacement = `${keyword} ${beforeReplacement}{`;
               afterReplacement += '}';
               replaceBefore = false;

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

@@ -7,20 +7,11 @@ exports.default = void 0;
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 const RETURN_STATEMENT = 'ReturnStatement';
 const BLOCK_STATEMENT = 'BlockStatement';
 
 const getBody = args => {
-  const _args = _slicedToArray(args, 2),
-        secondArg = _args[1];
+  const [, secondArg] = args;
 
   if (secondArg && (0, _utils.isFunction)(secondArg) && secondArg.body && secondArg.body.type === BLOCK_STATEMENT) {
     return secondArg.body.body;

package/lib/rules/no-truthy-falsy.js

@@ -31,8 +31,9 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              matcher = _parseExpectCall.matcher;
+        const {
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
 
         if (!matcher || !['toBeTruthy', 'toBeFalsy'].includes(matcher.name)) {
           return;

package/lib/rules/prefer-called-with.js

@@ -30,10 +30,10 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              modifier = _parseExpectCall.modifier,
-              matcher = _parseExpectCall.matcher; // Could check resolves/rejects here but not a likely idiom.
-
+        const {
+          modifier,
+          matcher
+        } = (0, _utils.parseExpectCall)(node); // Could check resolves/rejects here but not a likely idiom.
 
         if (matcher && !modifier) {
           if (['toBeCalled', 'toHaveBeenCalled'].includes(matcher.name)) {

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

@@ -9,14 +9,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 const isExpectAssertionsOrHasAssertionsCall = expression => {
   if (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)) {
     return false;
@@ -28,9 +20,7 @@ const isExpectAssertionsOrHasAssertionsCall = expression => {
     return expectAssertionName === 'hasAssertions';
   }
 
-  const _expression$arguments = _slicedToArray(expression.arguments, 1),
-        arg = _expression$arguments[0];
-
+  const [arg] = expression.arguments;
   return expression.arguments && expression.arguments.length === 1 && arg.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof arg.value === 'number' && Number.isInteger(arg.value);
 };
 

package/lib/rules/prefer-inline-snapshots.js

@@ -30,7 +30,9 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        const callee = node.callee;
+        const {
+          callee
+        } = node;
 
         if (callee.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || callee.property.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
           return;

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

@@ -9,14 +9,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 const findNodeObject = node => {
   if ('object' in node) {
     return node.object;
@@ -67,8 +59,10 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       AssignmentExpression(node) {
-        const left = node.left,
-              right = node.right;
+        const {
+          left,
+          right
+        } = node;
         if (left.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) return;
         const jestFnCall = getJestFnCall(right);
         if (!jestFnCall) return;
@@ -78,10 +72,7 @@ var _default = (0, _utils.createRule)({
 
           fix(fixer) {
             const leftPropQuote = left.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier ? "'" : '';
-
-            const _jestFnCall$arguments = _slicedToArray(jestFnCall.arguments, 1),
-                  arg = _jestFnCall$arguments[0];
-
+            const [arg] = jestFnCall.arguments;
             const argSource = arg && context.getSourceCode().getText(arg);
             const mockImplementation = argSource ? `.mockImplementation(${argSource})` : '.mockImplementation()';
             return [fixer.insertTextBefore(left, `jest.spyOn(`), fixer.replaceTextRange([left.object.range[1], left.property.range[0]], `, ${leftPropQuote}`), fixer.replaceTextRange([left.property.range[1], jestFnCall.range[1]], `${leftPropQuote})${mockImplementation}`)];

package/lib/rules/prefer-strict-equal.js

@@ -31,8 +31,9 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              matcher = _parseExpectCall.matcher;
+        const {
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
 
         if (matcher && (0, _utils.isParsedEqualityMatcherCall)(matcher, _utils.EqualityMatcher.toEqual)) {
           context.report({

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

@@ -46,8 +46,9 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              matcher = _parseExpectCall.matcher;
+        const {
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
 
         if (matcher && isNullEqualityMatcher(matcher)) {
           context.report({

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

@@ -46,8 +46,9 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              matcher = _parseExpectCall.matcher;
+        const {
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
 
         if (matcher && isUndefinedEqualityMatcher(matcher)) {
           context.report({

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

@@ -9,14 +9,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 const isBooleanLiteral = node => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
 
 /**
@@ -60,9 +52,7 @@ const buildToContainFuncExpectation = negated => negated ? `${_utils.ModifierNam
 const findPropertyDotToken = (member, sourceCode) => sourceCode.getFirstTokenBetween(member.object, member.property, token => token.value === '.');
 
 const getNegationFixes = (node, modifier, matcher, sourceCode, fixer, fileName) => {
-  const _node$arguments = _slicedToArray(node.arguments, 1),
-        containArg = _node$arguments[0];
-
+  const [containArg] = node.arguments;
   const negationPropertyDot = findPropertyDotToken(modifier.node, sourceCode);
   const toContainFunc = buildToContainFuncExpectation((0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value);
   /* istanbul ignore if */
@@ -75,9 +65,7 @@ const getNegationFixes = (node, modifier, matcher, sourceCode, fixer, fileName)
 };
 
 const getCommonFixes = (node, sourceCode, fileName) => {
-  const _node$arguments2 = _slicedToArray(node.arguments, 1),
-        containArg = _node$arguments2[0];
-
+  const [containArg] = node.arguments;
   const includesCallee = node.callee;
   const propertyDot = findPropertyDotToken(includesCallee, sourceCode);
   const closingParenthesis = sourceCode.getTokenAfter(containArg);
@@ -116,11 +104,13 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              _parseExpectCall$expe = _slicedToArray(_parseExpectCall.expect.arguments, 1),
-              includesCall = _parseExpectCall$expe[0],
-              matcher = _parseExpectCall.matcher,
-              modifier = _parseExpectCall.modifier;
+        const {
+          expect: {
+            arguments: [includesCall]
+          },
+          matcher,
+          modifier
+        } = (0, _utils.parseExpectCall)(node);
 
         if (!matcher || modifier && modifier.name !== _utils.ModifierName.not || !isBooleanEqualityMatcher(matcher) || !isFixableIncludesCallExpression(includesCall)) {
           return;
@@ -137,10 +127,7 @@ var _default = (0, _utils.createRule)({
             }
 
             const toContainFunc = buildToContainFuncExpectation(!(0, _utils.followTypeAssertionChain)(matcher.arguments[0]).value);
-
-            const _includesCall$argumen = _slicedToArray(includesCall.arguments, 1),
-                  containArg = _includesCall$argumen[0];
-
+            const [containArg] = includesCall.arguments;
             fixArr.push(fixer.replaceText(matcher.node.property, toContainFunc));
             fixArr.push(fixer.replaceText(matcher.arguments[0], sourceCode.getText(containArg)));
             return fixArr;

package/lib/rules/prefer-to-have-length.js

@@ -9,14 +9,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -41,10 +33,12 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              _parseExpectCall$expe = _slicedToArray(_parseExpectCall.expect.arguments, 1),
-              argument = _parseExpectCall$expe[0],
-              matcher = _parseExpectCall.matcher;
+        const {
+          expect: {
+            arguments: [argument]
+          },
+          matcher
+        } = (0, _utils.parseExpectCall)(node);
 
         if (!matcher || !(0, _utils.isParsedEqualityMatcherCall)(matcher) || !argument || argument.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression || !(0, _utils.isSupportedAccessor)(argument.property, 'length') || argument.property.type !== _experimentalUtils.AST_NODE_TYPES.Identifier) {
           return;

package/lib/rules/prefer-todo.js

@@ -9,14 +9,6 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 function isFunctionBodyEmpty(node) {
   /* istanbul ignore if https://github.com/typescript-eslint/typescript-eslint/issues/734 */
   if (!node.body) {
@@ -27,9 +19,7 @@ function isFunctionBodyEmpty(node) {
 }
 
 function isTestBodyEmpty(node) {
-  const _node$arguments = _slicedToArray(node.arguments, 2),
-        fn = _node$arguments[1];
-
+  const [, fn] = node.arguments;
   return fn && (0, _utils.isFunction)(fn) && isFunctionBodyEmpty(fn);
 }
 
@@ -61,11 +51,9 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        const _node$arguments2 = _slicedToArray(node.arguments, 2),
-              firstArg = _node$arguments2[0],
-              secondArg = _node$arguments2[1];
+        const [firstArg, secondArg] = node.arguments;
 
-        if (!isTargetedTestCase(node) || !(0, _utils.isStringNode)(firstArg)) {
+        if (!firstArg || !isTargetedTestCase(node) || !(0, _utils.isStringNode)(firstArg)) {
           return;
         }
 

package/lib/rules/{require-tothrow-message.js → require-to-throw-message.js}

@@ -16,7 +16,7 @@ var _default = (0, _utils.createRule)({
       recommended: false
     },
     messages: {
-      requireRethrow: 'Add an error message to {{ propertyName }}()'
+      addErrorMessage: 'Add an error message to {{ propertyName }}()'
     },
     type: 'suggestion',
     schema: []
@@ -30,19 +30,18 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const _parseExpectCall = (0, _utils.parseExpectCall)(node),
-              matcher = _parseExpectCall.matcher,
-              modifier = _parseExpectCall.modifier;
+        const {
+          matcher,
+          modifier
+        } = (0, _utils.parseExpectCall)(node);
 
         if (matcher && matcher.arguments && matcher.arguments.length === 0 && ['toThrow', 'toThrowError'].includes(matcher.name) && (!modifier || !(modifier.name === _utils.ModifierName.not || modifier.negation))) {
           // Look for `toThrow` calls with no arguments.
           context.report({
-            messageId: 'requireRethrow',
-            // todo: rename to 'addErrorMessage'
+            messageId: 'addErrorMessage',
             data: {
-              propertyName: matcher.name
+              matcherName: matcher.name
             },
-            // todo: rename to 'matcherName'
             node: matcher.node.property
           });
         }

package/lib/rules/utils.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getNodeName = getNodeName;
-exports.scopeHasLocalReference = exports.isDescribe = exports.isTestCase = exports.isHook = exports.isFunction = exports.TestCaseProperty = exports.DescribeProperty = exports.HookName = exports.TestCaseName = exports.DescribeAlias = exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.EqualityMatcher = exports.ModifierName = exports.isExpectMember = exports.isExpectCall = exports.getAccessorValue = exports.isSupportedAccessor = exports.hasOnlyOneArgument = exports.getStringValue = exports.isStringNode = exports.followTypeAssertionChain = exports.createRule = void 0;
+exports.scopeHasLocalReference = exports.getJestFunctionArguments = exports.isDescribeEach = exports.isDescribe = exports.isTestCase = exports.isHook = exports.isFunction = exports.TestCaseProperty = exports.DescribeProperty = exports.HookName = exports.TestCaseName = exports.DescribeAlias = exports.parseExpectCall = exports.isParsedEqualityMatcherCall = exports.EqualityMatcher = exports.ModifierName = exports.isExpectMember = exports.isExpectCall = exports.getAccessorValue = exports.isSupportedAccessor = exports.hasOnlyOneArgument = exports.getStringValue = exports.isStringNode = exports.followTypeAssertionChain = exports.createRule = void 0;
 
 var _path = require("path");
 
@@ -401,67 +401,53 @@ exports.isTestCase = isTestCase;
 const isDescribe = node => {
   return node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.name) || node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && node.callee.object.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.callee.object.name) && node.callee.property.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeProperty.hasOwnProperty(node.callee.property.name);
 };
+/**
+ * Checks if the given `describe` is a call to `describe.each`.
+ *
+ * @param {JestFunctionCallExpression<DescribeAlias>} node
+ * @return {node is JestFunctionCallExpression<DescribeAlias, DescribeProperty.each>}
+ */
+
 
 exports.isDescribe = isDescribe;
 
+const isDescribeEach = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, DescribeProperty.each);
+/**
+ * Gets the arguments of the given `JestFunctionCallExpression`.
+ *
+ * If the `node` is an `each` call, then the arguments of the actual suite
+ * are returned, rather then the `each` array argument.
+ *
+ * @param {JestFunctionCallExpression<DescribeAlias | TestCaseName>} node
+ *
+ * @return {Expression[]}
+ */
+
+
+exports.isDescribeEach = isDescribeEach;
+
+const getJestFunctionArguments = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, DescribeProperty.each) && node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.parent.arguments : node.arguments;
+
+exports.getJestFunctionArguments = getJestFunctionArguments;
+
 const collectReferences = scope => {
   const locals = new Set();
   const unresolved = new Set();
   let currentScope = scope;
 
   while (currentScope !== null) {
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
-
-    try {
-      for (var _iterator = currentScope.variables[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        const ref = _step.value;
-        const isReferenceDefined = ref.defs.some(def => {
-          return def.type !== 'ImplicitGlobalVariable';
-        });
-
-        if (isReferenceDefined) {
-          locals.add(ref.name);
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
+    for (const ref of currentScope.variables) {
+      const isReferenceDefined = ref.defs.some(def => {
+        return def.type !== 'ImplicitGlobalVariable';
+      });
+
+      if (isReferenceDefined) {
+        locals.add(ref.name);
       }
     }
 
-    var _iteratorNormalCompletion2 = true;
-    var _didIteratorError2 = false;
-    var _iteratorError2 = undefined;
-
-    try {
-      for (var _iterator2 = currentScope.through[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-        const ref = _step2.value;
-        unresolved.add(ref.identifier.name);
-      }
-    } catch (err) {
-      _didIteratorError2 = true;
-      _iteratorError2 = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-          _iterator2.return();
-        }
-      } finally {
-        if (_didIteratorError2) {
-          throw _iteratorError2;
-        }
-      }
+    for (const ref of currentScope.through) {
+      unresolved.add(ref.identifier.name);
     }
 
     currentScope = currentScope.upper;

package/lib/rules/valid-describe.js

@@ -9,18 +9,8 @@ var _experimentalUtils = require("@typescript-eslint/experimental-utils");
 
 var _utils = require("./utils");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 const paramsLocation = params => {
-  const _params = _slicedToArray(params, 1),
-        first = _params[0];
-
+  const [first] = params;
   const last = params[params.length - 1];
   return {
     start: first.loc.start,
@@ -28,8 +18,6 @@ const paramsLocation = params => {
   };
 };
 
-const isDescribeEach = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property, 'each');
-
 var _default = (0, _utils.createRule)({
   name: __filename,
   meta: {
@@ -41,7 +29,6 @@ var _default = (0, _utils.createRule)({
     },
     messages: {
       nameAndCallback: 'Describe requires name and callback arguments',
-      firstArgumentMustBeName: 'First argument must be name',
       secondArgumentMustBeFunction: 'Second argument must be function',
       noAsyncDescribeCallback: 'No async describe callback',
       unexpectedDescribeArgument: 'Unexpected argument(s) in describe callback',
@@ -54,32 +41,25 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isDescribe)(node) || isDescribeEach(node)) {
+        if (!(0, _utils.isDescribe)(node)) {
           return;
         }
 
-        if (node.arguments.length === 0) {
+        const nodeArguments = (0, _utils.getJestFunctionArguments)(node);
+
+        if (nodeArguments.length < 1) {
           return context.report({
             messageId: 'nameAndCallback',
             loc: node.loc
           });
         }
 
-        const _node$arguments = _slicedToArray(node.arguments, 2),
-              name = _node$arguments[0],
-              callback = _node$arguments[1];
-
-        if (!(0, _utils.isStringNode)(name)) {
-          context.report({
-            messageId: 'firstArgumentMustBeName',
-            loc: paramsLocation(node.arguments)
-          });
-        }
+        const [, callback] = nodeArguments;
 
         if (!callback) {
           context.report({
             messageId: 'nameAndCallback',
-            loc: paramsLocation(node.arguments)
+            loc: paramsLocation(nodeArguments)
           });
           return;
         }
@@ -87,7 +67,7 @@ var _default = (0, _utils.createRule)({
         if (!(0, _utils.isFunction)(callback)) {
           context.report({
             messageId: 'secondArgumentMustBeFunction',
-            loc: paramsLocation(node.arguments)
+            loc: paramsLocation(nodeArguments)
           });
           return;
         }
@@ -99,7 +79,7 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if (callback.params.length) {
+        if (!(0, _utils.isDescribeEach)(node) && callback.params.length) {
           context.report({
             messageId: 'unexpectedDescribeArgument',
             loc: paramsLocation(callback.params)