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

.gitignore

@@ -3,3 +3,4 @@ node_modules/
 coverage/
 lib/
 *.log
+package-lock.json

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: {
@@ -225,3 +225,37 @@ ruleTester.run('lowercase-name with ignore=it', rule, {
   ],
   invalid: [],
 });
+
+ruleTester.run('uppercase-name with ignore=top', rule, {
+  valid: [
+    {
+      code: `describe("Foo", () => {
+            test("bar", () => {
+             some_fn();
+           })
+        })`,
+      options: [{ ignore: [TopCase.top] }],
+    },
+    {
+      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] }],
+    },
+  ],
+  invalid: [],
+});

src/rules/lowercase-name.ts

@@ -5,6 +5,7 @@ import {
 } from '@typescript-eslint/experimental-utils';
 import {
   DescribeAlias,
+  TopCase,
   JestFunctionCallExpressionWithIdentifierCallee,
   JestFunctionName,
   TestCaseName,
@@ -52,6 +53,32 @@ const testDescription = (argument: ArgumentLiteral): string | null => {
   return argument.quasis[0].value.raw;
 };
 
+const jestTopFunctioName = (
+  node: CallExpressionWithCorrectCalleeAndArguments,
+  counter: number,
+) => {
+  const description = testDescription(node.arguments[0]);
+  if (description === null) {
+    return null;
+  }
+
+  if (counter !== 1) {
+    return null;
+  }
+
+  const firstCharacter = description.charAt(0);
+
+  if (!firstCharacter) {
+    return null;
+  }
+
+  if (firstCharacter === firstCharacter.toUpperCase()) {
+    return node.callee.name;
+  }
+
+  return null;
+}
+
 const jestFunctionName = (
   node: CallExpressionWithCorrectCalleeAndArguments,
 ) => {
@@ -93,7 +120,7 @@ export default createRule({
         properties: {
           ignore: {
             type: 'array',
-            items: { enum: ['describe', 'test', 'it'] },
+            items: { enum: ['describe', 'test', 'it', 'top'] },
             additionalItems: false,
           },
         },
@@ -103,14 +130,25 @@ export default createRule({
   } as const,
   defaultOptions: [{ ignore: [] } as { ignore: readonly JestFunctionName[] }],
   create(context, [{ ignore }]) {
+    let counter: number = 0
     return {
+
       CallExpression(node) {
         if (!isJestFunctionWithLiteralArg(node)) {
           return;
         }
+
+        if (isTestCase || isDescribe) {
+          counter += 1
+        }
+
+        const topMethod = jestTopFunctioName(node, counter);
+
+        const topMethodIgnore = topMethod && ignore.includes(TopCase.top);
+
         const erroneousMethod = jestFunctionName(node);
 
-        if (erroneousMethod && !ignore.includes(node.callee.name)) {
+        if (erroneousMethod && !ignore.includes(node.callee.name) && topMethodIgnore!==true) {
           context.report({
             messageId: 'unexpectedLowercase',
             data: { method: erroneousMethod },
@@ -137,4 +175,4 @@ export default createRule({
       },
     };
   },
-});
+});

src/rules/utils.ts

@@ -550,7 +550,11 @@ 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 {