feat: improve how jest function calls are resolved to account for import aliases (#1122)

* feat: improve how jest function calls are resolved to account for import aliases

* feat(no-focused-tests): switch to using new jest fn call parser

* feat(require-top-level-describe): switch to using new jest fn call parser

* feat(no-test-prefixes): switch to using new jest fn call parser

* feat(prefer-lowercase-title): switch to using new jest fn call parser

* feat(valid-title): switch to using new jest fn call parser

* feat(no-identical-titles): switch to using new jest fn call parser

* feat(no-duplicate-hooks): switch to using new jest fn call parser

* feat(consistent-test-it): switch to using new jest fn call parser

* feat: switch rules to using new jest fn call parser

* chore: remove unused utils

* refactor: move `scopeHasLocalReference` util function to deduplicate internal code

* refactor: ensure complete test coverage

* fix: consider imported `jest` property as a jest function

* test: cover advanced cases for `parseJestFnCall`

* chore: remove duplicated entries in valid jest fn call chains array

* chore: linting fixes

* fix: remove `failing` support (for now)

* refactor: rename variable to be consistent

* test: remove empty suggestions check

Author: G-Rath

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

@@ -61,6 +61,52 @@ ruleTester.run('consistent-test-it with fn=test', rule, {
         },
       ],
     },
+    {
+      code: dedent`
+        import { it } from '@jest/globals';
+
+        it("foo")
+      `,
+      output: dedent`
+        import { it } from '@jest/globals';
+
+        test("foo")
+      `,
+      options: [{ fn: TestCaseName.test }],
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'consistentMethod',
+          data: {
+            testKeyword: TestCaseName.test,
+            oppositeTestKeyword: TestCaseName.it,
+          },
+        },
+      ],
+    },
+    {
+      code: dedent`
+        import { it as testThisThing } from '@jest/globals';
+
+        testThisThing("foo")
+      `,
+      output: dedent`
+        import { it as testThisThing } from '@jest/globals';
+
+        test("foo")
+      `,
+      options: [{ fn: TestCaseName.test }],
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'consistentMethod',
+          data: {
+            testKeyword: TestCaseName.test,
+            oppositeTestKeyword: TestCaseName.it,
+          },
+        },
+      ],
+    },
     {
       code: 'xit("foo")',
       output: 'xtest("foo")',
@@ -495,6 +541,52 @@ ruleTester.run('consistent-test-it with fn=test and withinDescribe=it ', rule, {
         },
       ],
     },
+    {
+      code: dedent`
+        import { xtest as dontTestThis } from '@jest/globals';
+
+        describe("suite", () => { dontTestThis("foo") });
+      `,
+      output: dedent`
+        import { xtest as dontTestThis } from '@jest/globals';
+
+        describe("suite", () => { xit("foo") });
+      `,
+      options: [{ fn: TestCaseName.test, withinDescribe: TestCaseName.it }],
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'consistentMethodWithinDescribe',
+          data: {
+            testKeywordWithinDescribe: TestCaseName.it,
+            oppositeTestKeyword: TestCaseName.test,
+          },
+        },
+      ],
+    },
+    {
+      code: dedent`
+        import { describe as context, xtest as dontTestThis } from '@jest/globals';
+
+        context("suite", () => { dontTestThis("foo") });
+      `,
+      output: dedent`
+        import { describe as context, xtest as dontTestThis } from '@jest/globals';
+
+        context("suite", () => { xit("foo") });
+      `,
+      options: [{ fn: TestCaseName.test, withinDescribe: TestCaseName.it }],
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'consistentMethodWithinDescribe',
+          data: {
+            testKeywordWithinDescribe: TestCaseName.it,
+            oppositeTestKeyword: TestCaseName.test,
+          },
+        },
+      ],
+    },
     {
       code: 'describe("suite", () => { test.skip("foo") })',
       output: 'describe("suite", () => { it.skip("foo") })',

src/rules/__tests__/expect-expect.test.ts

@@ -273,3 +273,82 @@ ruleTester.run('wildcards', rule, {
     },
   ],
 });
+
+ruleTester.run('expect-expect (aliases)', rule, {
+  valid: [
+    {
+      code: dedent`
+        import { test } from '@jest/globals';
+
+        test('should pass', () => {
+          expect(true).toBeDefined();
+          foo(true).toBe(true);
+        });
+      `,
+      options: [{ assertFunctionNames: ['expect', 'foo'] }],
+      parserOptions: { sourceType: 'module' },
+    },
+    {
+      code: dedent`
+        import { test as checkThat } from '@jest/globals';
+
+        checkThat('this passes', () => {
+          expect(true).toBeDefined();
+          foo(true).toBe(true);
+        });
+      `,
+      options: [{ assertFunctionNames: ['expect', 'foo'] }],
+      parserOptions: { sourceType: 'module' },
+    },
+    {
+      code: dedent`
+        const { test } = require('@jest/globals');
+
+        test('verifies chained expect method call', () => {
+          tester
+            .foo()
+            .bar()
+            .expect(456);
+        });
+      `,
+      options: [{ assertFunctionNames: ['tester.foo.bar.expect'] }],
+      parserOptions: { sourceType: 'module' },
+    },
+  ],
+
+  invalid: [
+    {
+      code: dedent`
+        import { test as checkThat } from '@jest/globals';
+
+        checkThat('this passes', () => {
+          // ...
+        });
+      `,
+      options: [{ assertFunctionNames: ['expect', 'foo'] }],
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'noAssertions',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        import { test as checkThat } from '@jest/globals';
+
+        checkThat.skip('this passes', () => {
+          // ...
+        });
+      `,
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'noAssertions',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+  ],
+});