feat: add no-confusing-set-time rule

README.md

@@ -220,6 +220,7 @@ set to warn in.\
 | [no-commented-out-tests](docs/rules/no-commented-out-tests.md)               | Disallow commented out tests                                              |     | ✅  |     |     |     |
 | [no-conditional-expect](docs/rules/no-conditional-expect.md)                 | Disallow calling `expect` conditionally                                   | ✅  |     |     |     |     |
 | [no-conditional-in-test](docs/rules/no-conditional-in-test.md)               | Disallow conditional logic in tests                                       |     |     |     |     |     |
+| [no-confusing-set-timeout](docs/rules/no-confusing-set-timeout.md)           | Disallow using confusing setTimeout in test                               |     |     |     |     |     |
 | [no-deprecated-functions](docs/rules/no-deprecated-functions.md)             | Disallow use of deprecated functions                                      | ✅  |     | 🔧  |     |     |
 | [no-disabled-tests](docs/rules/no-disabled-tests.md)                         | Disallow disabled tests                                                   |     | ✅  |     |     |     |
 | [no-done-callback](docs/rules/no-done-callback.md)                           | Disallow using a callback in asynchronous tests and hooks                 | ✅  |     |     | 💡  |     |

docs/rules/no-confusing-set-timeout.md

@@ -0,0 +1,63 @@
+# Disallow using confusing setTimeout in test (`no-confusing-set-timeout`)
+
+<!-- end auto-generated rule header -->
+
+`jest.setTimeout` can be called multiple times anywhere within a single test
+file. However, only the last call will have an effect, and it will actually be
+invoked before any other jest functions.
+
+## Rule details
+
+This rule describes some tricky ways about `jest.setTimeout` that should not
+recommend in Jest:
+
+- should set `jest.setTimeout` in any testsuite methods before(such as
+  `describe`, `test` or `it`);
+- should set `jest.setTimeout` in global scope.
+- should only call `jest.setTimeout` once in a single test file;
+
+Examples of **incorrect** code for this rule:
+
+```js
+describe('test foo', () => {
+  jest.setTimeout(1000);
+  it('test-description', () => {
+    // test logic;
+  });
+});
+
+describe('test bar', () => {
+  it('test-description', () => {
+    jest.setTimeout(1000);
+    // test logic;
+  });
+});
+
+test('foo-bar', () => {
+  jest.setTimeout(1000);
+});
+
+describe('unit test', () => {
+  beforeEach(() => {
+    jest.setTimeout(1000);
+  });
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+jest.setTimeout(500);
+test('test test', () => {
+  // do some stuff
+});
+```
+
+```js
+jest.setTimeout(1000);
+describe('test bar bar', () => {
+  it('test-description', () => {
+    // test logic;
+  });
+});
+```

src/__tests__/__snapshots__/rules.test.ts.snap

@@ -18,6 +18,7 @@ exports[`rules should export configs that refer to actual rules 1`] = `
       "jest/no-commented-out-tests": "error",
       "jest/no-conditional-expect": "error",
       "jest/no-conditional-in-test": "error",
+      "jest/no-confusing-set-timeout": "error",
       "jest/no-deprecated-functions": "error",
       "jest/no-disabled-tests": "error",
       "jest/no-done-callback": "error",

src/__tests__/rules.test.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'fs';
 import { resolve } from 'path';
 import plugin from '../';
 
-const numberOfRules = 52;
+const numberOfRules = 53;
 const ruleNames = Object.keys(plugin.rules);
 const deprecatedRules = Object.entries(plugin.rules)
   .filter(([, rule]) => rule.meta.deprecated)

src/rules/__tests__/no-confusing-set-timeout.test.ts

@@ -0,0 +1,242 @@
+import { TSESLint } from '@typescript-eslint/utils';
+import dedent from 'dedent';
+import rule from '../no-confusing-set-timeout';
+import { espreeParser } from './test-utils';
+
+const ruleTester = new TSESLint.RuleTester({
+  parser: espreeParser,
+  parserOptions: {
+    ecmaVersion: 2020,
+  },
+});
+
+ruleTester.run('no-confusing-set-timeout', rule, {
+  valid: [
+    dedent`
+      jest.setTimeout(1000);
+      describe('A', () => {
+        beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+      });
+    `,
+    dedent`
+      jest.setTimeout(1000);
+      window.setTimeout(6000)
+      describe('A', () => {
+        beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('test foo', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+      });
+    `,
+    {
+      code: dedent`
+        import { handler } from 'dep/mod';
+        jest.setTimeout(800);
+        describe('A', () => {
+          beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        });
+      `,
+      parserOptions: { sourceType: 'module' },
+    },
+    dedent`
+      function handler() {}
+      jest.setTimeout(800);
+      describe('A', () => {
+        beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+      });
+    `,
+    dedent`
+      const { handler } = require('dep/mod');
+      jest.setTimeout(800);
+      describe('A', () => {
+        beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+      });
+    `,
+    dedent`
+      jest.setTimeout(1000);
+      window.setTimeout(60000);
+    `,
+    'window.setTimeout(60000);',
+    'setTimeout(1000);',
+    dedent`
+      jest.setTimeout(1000);
+      test('test case', () => {
+        setTimeout(() => {
+          Promise.resolv();
+        }, 5000);
+      });
+    `,
+    dedent`
+      test('test case', () => {
+        setTimeout(() => {
+          Promise.resolv();
+        }, 5000);
+      });
+    `,
+  ],
+  invalid: [
+    {
+      code: dedent`
+        jest.setTimeout(1000);
+        setTimeout(1000);
+        window.setTimeout(1000);
+        describe('A', () => {
+          beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        });
+        jest.setTimeout(800);
+      `,
+      errors: [
+        {
+          messageId: 'orderSetTimeout',
+          line: 9,
+          column: 1,
+        },
+        {
+          messageId: 'multipleSetTimeouts',
+          line: 9,
+          column: 1,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        describe('A', () => {
+          jest.setTimeout(800);
+          beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        });
+      `,
+      errors: [
+        {
+          messageId: 'globalSetTimeout',
+          line: 2,
+          column: 3,
+        },
+        {
+          messageId: 'orderSetTimeout',
+          line: 2,
+          column: 3,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        describe('B', () => {
+          it('B.1', async () => {
+            await new Promise((resolve) => {
+              jest.setTimeout(1000);
+              setTimeout(resolve, 10000).unref();
+            });
+          });
+          it('B.2', async () => {
+            await new Promise((resolve) => { setTimeout(resolve, 10000).unref(); });
+          });
+        });
+      `,
+      errors: [
+        {
+          messageId: 'globalSetTimeout',
+          line: 4,
+          column: 7,
+        },
+        {
+          messageId: 'orderSetTimeout',
+          line: 4,
+          column: 7,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        test('test-suite', () => {
+          jest.setTimeout(1000);
+        });
+      `,
+      errors: [
+        {
+          messageId: 'globalSetTimeout',
+          line: 2,
+          column: 3,
+        },
+        {
+          messageId: 'orderSetTimeout',
+          line: 2,
+          column: 3,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        describe('A', () => {
+          beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        });
+        jest.setTimeout(1000);
+      `,
+      errors: [
+        {
+          messageId: 'orderSetTimeout',
+          line: 6,
+          column: 1,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        import { jest } from '@jest/globals';
+        {
+          jest.setTimeout(800);
+        }
+        describe('A', () => {
+          beforeEach(async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.1', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+          it('A.2', async () => { await new Promise(resolve => { setTimeout(resolve, 10000).unref(); });});
+        });
+      `,
+      parserOptions: { sourceType: 'module' },
+      errors: [
+        {
+          messageId: 'globalSetTimeout',
+          line: 3,
+          column: 3,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        jest.setTimeout(800);
+        jest.setTimeout(900);
+      `,
+      errors: [
+        {
+          messageId: 'multipleSetTimeouts',
+          line: 2,
+          column: 1,
+        },
+      ],
+    },
+    {
+      code: dedent`
+        expect(1 + 2).toEqual(3);
+        jest.setTimeout(800);
+      `,
+      errors: [
+        {
+          messageId: 'orderSetTimeout',
+          line: 2,
+          column: 1,
+        },
+      ],
+    },
+  ],
+});

src/rules/no-confusing-set-timeout.ts

@@ -0,0 +1,66 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import { createRule, getNodeName, parseJestFnCall } from './utils';
+
+function isJestSetTimeout(node: TSESTree.Node) {
+  return getNodeName(node) === 'jest.setTimeout';
+}
+
+export default createRule({
+  name: __filename,
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Disallow using confusing setTimeout in test',
+      recommended: false,
+    },
+    messages: {
+      globalSetTimeout: '`jest.setTimeout` should be call in `global` scope.',
+      multipleSetTimeouts:
+        'Do not call `jest.setTimeout` multiple times, as only the last call will have an effect.',
+      orderSetTimeout:
+        '`jest.setTimeout` should be placed before any other jest methods',
+    },
+    type: 'problem',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    let seenJestTimeout = false;
+    let shouldEmitOrderSetTimeout = false;
+
+    return {
+      CallExpression(node) {
+        const scope = context.getScope();
+        const jestFnCall = parseJestFnCall(node, context);
+
+        if (!jestFnCall) {
+          return;
+        }
+
+        const result = isJestSetTimeout(node);
+
+        if (!result) {
+          if (jestFnCall.type !== 'unknown') {
+            shouldEmitOrderSetTimeout = true;
+          }
+
+          return;
+        }
+
+        if (!['global', 'module'].includes(scope.type)) {
+          context.report({ messageId: 'globalSetTimeout', node });
+        }
+
+        if (shouldEmitOrderSetTimeout) {
+          context.report({ messageId: 'orderSetTimeout', node });
+        }
+
+        if (seenJestTimeout) {
+          context.report({ messageId: 'multipleSetTimeouts', node });
+        } else {
+          seenJestTimeout = result;
+        }
+      },
+    };
+  },
+});