fix: revert change causing regressions for test.each (#713)

Fixes #710
Fixes #711

Author: SimenB

src/rules/__tests__/consistent-test-it.test.ts

@@ -144,20 +144,6 @@ ruleTester.run('consistent-test-it with fn=test', rule, {
         },
       ],
     },
-    {
-      code: 'it.each``("foo")',
-      output: 'test.each``("foo")',
-      options: [{ fn: TestCaseName.test }],
-      errors: [
-        {
-          messageId: 'consistentMethod',
-          data: {
-            testKeyword: TestCaseName.test,
-            oppositeTestKeyword: TestCaseName.it,
-          },
-        },
-      ],
-    },
     {
       code: 'describe("suite", () => { it("foo") })',
       output: 'describe("suite", () => { test("foo") })',
@@ -299,20 +285,6 @@ ruleTester.run('consistent-test-it with fn=it', rule, {
         },
       ],
     },
-    {
-      code: 'test.each``("foo")',
-      output: 'it.each``("foo")',
-      options: [{ fn: TestCaseName.it }],
-      errors: [
-        {
-          messageId: 'consistentMethod',
-          data: {
-            testKeyword: TestCaseName.it,
-            oppositeTestKeyword: TestCaseName.test,
-          },
-        },
-      ],
-    },
     {
       code: 'describe("suite", () => { test("foo") })',
       output: 'describe("suite", () => { it("foo") })',

src/rules/__tests__/no-disabled-tests.test.ts

@@ -88,22 +88,6 @@ ruleTester.run('no-disabled-tests', rule, {
       code: 'test.skip("foo", function () {})',
       errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
     },
-    {
-      code: 'it.skip.each``("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
-    {
-      code: 'test.skip.each``("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
-    {
-      code: 'it.skip.each([])("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
-    {
-      code: 'test.skip.each([])("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
     {
       code: 'test.concurrent.skip("foo", function () {})',
       errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
@@ -124,22 +108,6 @@ ruleTester.run('no-disabled-tests', rule, {
       code: 'xtest("foo", function () {})',
       errors: [{ messageId: 'disabledTest', column: 1, line: 1 }],
     },
-    {
-      code: 'xit.each``("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
-    {
-      code: 'xtest.each``("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
-    {
-      code: 'xit.each([])("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
-    {
-      code: 'xtest.each([])("foo", function () {})',
-      errors: [{ messageId: 'skippedTest', column: 1, line: 1 }],
-    },
     {
       code: 'it("has title but no callback")',
       errors: [{ messageId: 'missingFunction', column: 1, line: 1 }],

src/rules/__tests__/no-done-callback.test.ts

@@ -18,6 +18,7 @@ ruleTester.run('no-done-callback', rule, {
     'test.each``("something", ({ a, b }) => {})',
     'test.each()("something", ({ a, b }) => {})',
     'it.each()("something", ({ a, b }) => {})',
+    'it.each([])("something", (a, b) => {})',
     'it.each``("something", ({ a, b }) => {})',
     'test("something", async function () {})',
     'test("something", someArg)',
@@ -389,45 +390,5 @@ ruleTester.run('no-done-callback', rule, {
         },
       ],
     },
-    {
-      code: 'test.each``("something", ({ a, b }, done) => { done(); })',
-      errors: [
-        {
-          messageId: 'noDoneCallback',
-          line: 1,
-          column: 37,
-        },
-      ],
-    },
-    {
-      code: 'test.each()("something", ({ a, b }, done) => { done(); })',
-      errors: [
-        {
-          messageId: 'noDoneCallback',
-          line: 1,
-          column: 37,
-        },
-      ],
-    },
-    {
-      code: 'it.each``("something", ({ a, b }, done) => { done(); })',
-      errors: [
-        {
-          messageId: 'noDoneCallback',
-          line: 1,
-          column: 35,
-        },
-      ],
-    },
-    {
-      code: 'it.each()("something", ({ a, b }, done) => { done(); })',
-      errors: [
-        {
-          messageId: 'noDoneCallback',
-          line: 1,
-          column: 35,
-        },
-      ],
-    },
   ],
 });

src/rules/__tests__/no-test-prefixes.test.ts

@@ -106,55 +106,5 @@ ruleTester.run('no-test-prefixes', rule, {
         },
       ],
     },
-    {
-      code: 'xit.each``("foo", function () {})',
-      output: 'it.skip.each``("foo", function () {})',
-      parserOptions: { ecmaVersion: 6 },
-      errors: [
-        {
-          messageId: 'usePreferredName',
-          data: { preferredNodeName: 'it.skip.each' },
-          column: 1,
-          line: 1,
-        },
-      ],
-    },
-    {
-      code: 'xtest.each``("foo", function () {})',
-      output: 'test.skip.each``("foo", function () {})',
-      parserOptions: { ecmaVersion: 6 },
-      errors: [
-        {
-          messageId: 'usePreferredName',
-          data: { preferredNodeName: 'test.skip.each' },
-          column: 1,
-          line: 1,
-        },
-      ],
-    },
-    {
-      code: 'xit.each([])("foo", function () {})',
-      output: 'it.skip.each([])("foo", function () {})',
-      errors: [
-        {
-          messageId: 'usePreferredName',
-          data: { preferredNodeName: 'it.skip.each' },
-          column: 1,
-          line: 1,
-        },
-      ],
-    },
-    {
-      code: 'xtest.each([])("foo", function () {})',
-      output: 'test.skip.each([])("foo", function () {})',
-      errors: [
-        {
-          messageId: 'usePreferredName',
-          data: { preferredNodeName: 'test.skip.each' },
-          column: 1,
-          line: 1,
-        },
-      ],
-    },
   ],
 });

src/rules/consistent-test-it.ts

@@ -82,11 +82,6 @@ export default createRule<
           describeNestingLevel++;
         }
 
-        const funcNode =
-          node.callee.type === AST_NODE_TYPES.TaggedTemplateExpression
-            ? node.callee.tag
-            : node.callee;
-
         if (
           isTestCase(node) &&
           describeNestingLevel === 0 &&
@@ -98,7 +93,7 @@ export default createRule<
             messageId: 'consistentMethod',
             node: node.callee,
             data: { testKeyword, oppositeTestKeyword },
-            fix: buildFixer(funcNode, nodeName, testKeyword),
+            fix: buildFixer(node.callee, nodeName, testKeyword),
           });
         }
 
@@ -115,7 +110,7 @@ export default createRule<
             messageId: 'consistentMethodWithinDescribe',
             node: node.callee,
             data: { testKeywordWithinDescribe, oppositeTestKeyword },
-            fix: buildFixer(funcNode, nodeName, testKeywordWithinDescribe),
+            fix: buildFixer(node.callee, nodeName, testKeywordWithinDescribe),
           });
         }
       },

src/rules/no-disabled-tests.ts

@@ -39,9 +39,6 @@ export default createRule({
       CallExpression(node) {
         const functionName = getNodeName(node.callee);
 
-        // prevent duplicate warnings for it.each()()
-        if (node.callee.type === 'CallExpression') return;
-
         switch (functionName) {
           case 'describe.skip':
             context.report({ messageId: 'skippedTestSuite', node });
@@ -51,10 +48,6 @@ export default createRule({
           case 'it.concurrent.skip':
           case 'test.skip':
           case 'test.concurrent.skip':
-          case 'it.skip.each':
-          case 'test.skip.each':
-          case 'xit.each':
-          case 'xtest.each':
             context.report({ messageId: 'skippedTest', node });
             break;
         }

src/rules/no-done-callback.ts

@@ -2,22 +2,11 @@ import {
   AST_NODE_TYPES,
   TSESTree,
 } from '@typescript-eslint/experimental-utils';
-import {
-  createRule,
-  getNodeName,
-  isFunction,
-  isHook,
-  isTestCase,
-} from './utils';
+import { createRule, isFunction, isHook, isTestCase } from './utils';
 
 const findCallbackArg = (
   node: TSESTree.CallExpression,
-  isJestEach: boolean,
 ): TSESTree.CallExpression['arguments'][0] | null => {
-  if (isJestEach) {
-    return node.arguments[1];
-  }
-
   if (isHook(node) && node.arguments.length >= 1) {
     return node.arguments[0];
   }
@@ -52,21 +41,17 @@ export default createRule({
   create(context) {
     return {
       CallExpression(node) {
-        // done is the second argument for it.each, not the first
-        const isJestEach = getNodeName(node.callee)?.endsWith('.each') ?? false;
-
-        const callback = findCallbackArg(node, isJestEach);
-        const callbackArgIndex = Number(isJestEach);
+        const callback = findCallbackArg(node);
 
         if (
           !callback ||
           !isFunction(callback) ||
-          callback.params.length !== 1 + callbackArgIndex
+          callback.params.length !== 1
         ) {
           return;
         }
 
-        const argument = callback.params[callbackArgIndex];
+        const [argument] = callback.params;
 
         if (argument.type !== AST_NODE_TYPES.Identifier) {
           context.report({

src/rules/no-test-prefixes.ts

@@ -1,4 +1,3 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/experimental-utils';
 import { createRule, getNodeName, isDescribe, isTestCase } from './utils';
 
 export default createRule({
@@ -28,17 +27,12 @@ export default createRule({
 
         if (!preferredNodeName) return;
 
-        const funcNode =
-          node.callee.type === AST_NODE_TYPES.TaggedTemplateExpression
-            ? node.callee.tag
-            : node.callee;
-
         context.report({
           messageId: 'usePreferredName',
           node: node.callee,
           data: { preferredNodeName },
           fix(fixer) {
-            return [fixer.replaceText(funcNode, preferredNodeName)];
+            return [fixer.replaceText(node.callee, preferredNodeName)];
           },
         });
       },
@@ -49,14 +43,12 @@ export default createRule({
 function getPreferredNodeName(nodeName: string) {
   const firstChar = nodeName.charAt(0);
 
-  const suffix = nodeName.endsWith('.each') ? '.each' : '';
-
   if (firstChar === 'f') {
-    return `${nodeName.slice(1).replace('.each', '')}.only${suffix}`;
+    return `${nodeName.slice(1)}.only`;
   }
 
   if (firstChar === 'x') {
-    return `${nodeName.slice(1).replace('.each', '')}.skip${suffix}`;
+    return `${nodeName.slice(1)}.skip`;
   }
 
   return null;

src/rules/utils.ts

@@ -580,16 +580,10 @@ export interface JestFunctionCallExpressionWithIdentifierCallee<
   callee: JestFunctionIdentifier<FunctionName>;
 }
 
-interface JestFunctionCallExpressionWithTaggedTemplateCallee
-  extends TSESTree.CallExpression {
-  callee: TSESTree.TaggedTemplateExpression;
-}
-
 export type JestFunctionCallExpression<
   FunctionName extends JestFunctionName = JestFunctionName
 > =
   | JestFunctionCallExpressionWithMemberExpressionCallee<FunctionName>
-  | JestFunctionCallExpressionWithTaggedTemplateCallee
   | JestFunctionCallExpressionWithIdentifierCallee<FunctionName>;
 
 const joinNames = (a: string | null, b: string | null): string | null =>
@@ -598,8 +592,7 @@ const joinNames = (a: string | null, b: string | null): string | null =>
 export function getNodeName(
   node:
     | JestFunctionMemberExpression<JestFunctionName>
-    | JestFunctionIdentifier<JestFunctionName>
-    | TSESTree.TaggedTemplateExpression,
+    | JestFunctionIdentifier<JestFunctionName>,
 ): string;
 export function getNodeName(node: TSESTree.Node): string | null;
 export function getNodeName(node: TSESTree.Node): string | null {
@@ -608,8 +601,6 @@ export function getNodeName(node: TSESTree.Node): string | null {
   }
 
   switch (node.type) {
-    case AST_NODE_TYPES.TaggedTemplateExpression:
-      return getNodeName(node.tag);
     case AST_NODE_TYPES.MemberExpression:
       return joinNames(getNodeName(node.object), getNodeName(node.property));
     case AST_NODE_TYPES.NewExpression:
@@ -660,11 +651,6 @@ export const isTestCase = (
 ): node is JestFunctionCallExpression<TestCaseName> =>
   (node.callee.type === AST_NODE_TYPES.Identifier &&
     TestCaseName.hasOwnProperty(node.callee.name)) ||
-  // e.g. it.each``()
-  (node.callee.type === AST_NODE_TYPES.TaggedTemplateExpression &&
-    node.callee.tag.type === AST_NODE_TYPES.MemberExpression &&
-    isSupportedAccessor(node.callee.tag.property, TestCaseProperty.each)) ||
-  // e.g. it.concurrent.{skip,only}
   (node.callee.type === AST_NODE_TYPES.MemberExpression &&
     node.callee.property.type === AST_NODE_TYPES.Identifier &&
     TestCaseProperty.hasOwnProperty(node.callee.property.name) &&