feat(rules): option for rule to allow uppercase for top level describes

package.json

@@ -37,7 +37,8 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "^1.13.0"
+    "@typescript-eslint/experimental-utils": "^1.13.0",
+    "build": "^0.1.4"
   },
   "devDependencies": {
     "@babel/cli": "^7.4.4",

src/rules/__tests__/lowercase-name.test.ts

@@ -1,6 +1,6 @@
 import { TSESLint } from '@typescript-eslint/experimental-utils';
 import rule from '../lowercase-name';
-import { DescribeAlias, TestCaseName } from '../utils';
+import { DescribeAlias, TestCaseName, TopCase } from '../utils';
 
 const ruleTester = new TSESLint.RuleTester({
   parserOptions: {
@@ -230,6 +230,51 @@ ruleTester.run('lowercase-name with ignore=it', rule, {
   invalid: [],
 });
 
+ruleTester.run('uppercase-name with ignore=top', rule, {
+  valid: [
+    {
+      code: `describe("Foo", () => {
+                 it("bar", () => {
+                 some_fn();
+                })
+         })`,
+      options: [{ ignore: [TopCase.top] }],
+    },
+    {
+      code: 'describe(`Foo`, function () {})',
+      options: [{ ignore: [TopCase.top] }],
+    },
+    {
+      code: 'test(`Foo`, function () {})',
+      options: [{ ignore: [TopCase.top] }],
+    },
+    {
+      code: 'it(`Foo`, function () {})',
+      options: [{ ignore: [TopCase.top] }],
+    },
+    {
+      code: `describe('MyFirstClass', () => {});
+      describe('MySecondClass', () => {});`,
+      options: [{ ignore: [TopCase.top] }],
+    },
+  ],
+  invalid: [
+    {
+      code: `describe("Foo", () => {test("Bar foo", () => {})})`,
+      options: [{ ignore: [TopCase.top] }],
+      output: `describe("Foo", () => {test("bar foo", () => {})})`,
+      errors: [
+        {
+          messageId: 'unexpectedLowercase',
+          data: { method: TestCaseName.test },
+          column: 24,
+          line: 1,
+        },
+      ],
+    },
+  ],
+});
+
 ruleTester.run('lowercase-name with allowedPrefixes', rule, {
   valid: [
     {

src/rules/lowercase-name.ts

@@ -8,9 +8,11 @@ import {
   JestFunctionCallExpressionWithIdentifierCallee,
   JestFunctionName,
   TestCaseName,
+  TopCase,
   createRule,
   isDescribe,
   isTestCase,
+  isTopMostJestFunction,
 } from './utils';
 
 type ArgumentLiteral = TSESTree.Literal | TSESTree.TemplateLiteral;
@@ -52,6 +54,27 @@ const testDescription = (argument: ArgumentLiteral): string | null => {
   return argument.quasis[0].value.raw;
 };
 
+const jestTopFunctioName = (
+  node: CallExpressionWithCorrectCalleeAndArguments,
+  isTop: boolean,
+) => {
+  const description = testDescription(node.arguments[0]);
+  if (isTop !== true) {
+    return null;
+  }
+
+  if (description === null) {
+    return null;
+  }
+  const firstCharacter = description.charAt(0);
+
+  if (firstCharacter === firstCharacter.toUpperCase()) {
+    return node.callee.name;
+  }
+
+  return null;
+};
+
 const jestFunctionName = (
   node: CallExpressionWithCorrectCalleeAndArguments,
   allowedPrefixes: readonly string[],
@@ -105,7 +128,7 @@ export default createRule<
         properties: {
           ignore: {
             type: 'array',
-            items: { enum: ['describe', 'test', 'it'] },
+            items: { enum: ['describe', 'test', 'it', 'top'] },
             additionalItems: false,
           },
           allowedPrefixes: {
@@ -118,13 +141,20 @@ export default createRule<
       },
     ],
   } as const,
+
   defaultOptions: [{ ignore: [], allowedPrefixes: [] }],
   create(context, [{ ignore = [], allowedPrefixes = [] }]) {
     return {
       CallExpression(node) {
         if (!isJestFunctionWithLiteralArg(node)) {
           return;
         }
+
+        const topMethod = jestTopFunctioName(node, isTopMostJestFunction(node));
+        if (topMethod && ignore.includes(TopCase.top)) {
+          return;
+        }
+
         const erroneousMethod = jestFunctionName(node, allowedPrefixes);
 
         if (erroneousMethod && !ignore.includes(node.callee.name)) {

src/rules/utils.ts

@@ -550,7 +550,15 @@ export enum TestCaseProperty {
   'todo' = 'todo',
 }
 
-export type JestFunctionName = DescribeAlias | TestCaseName | HookName;
+export enum TopCase {
+  'top' = 'top',
+}
+
+export type JestFunctionName =
+  | DescribeAlias
+  | TestCaseName
+  | HookName
+  | TopCase;
 
 export interface JestFunctionIdentifier<FunctionName extends JestFunctionName>
   extends TSESTree.Identifier {
@@ -652,6 +660,13 @@ export const isDescribe = (
   );
 };
 
+export function isTopMostJestFunction(node: TSESTree.CallExpression): boolean {
+  if (node.parent && node.parent.parent && node.parent.parent.parent === null) {
+    return true;
+  }
+  return false;
+}
+
 const collectReferences = (scope: TSESLint.Scope.Scope) => {
   const locals = new Set();
   const unresolved = new Set();