fix(require-test-timeout): treat imported bindings as explicit timeouts (#906)

resolveConstTimeout only walked Variable definitions, so an imported
const used as a timeout argument resolved to undefined and the rule
reported a missing timeout. Same-file consts were already accepted via
#887/#889; imports were not.

ImportBinding definitions cannot be resolved cross-file, so accept them
opaquely: if a developer named the imported identifier in the timeout
position, treat it as an explicit timeout and let the rule pass. Same
behaviour as the existing handling for ancestor-scope const bindings.

Tests added (positive + negative axes):
- imported identifier as third-arg timeout (test + it)
- imported identifier in { timeout } object property
- imported identifier as { timeout } options object
- default-imported binding
- importing a binding without using it as a timeout still reports

Closes #892

Author: spokodev

src/rules/require-test-timeout.ts

@@ -92,6 +92,12 @@ export default createEslintRule<Options, MESSAGE_ID>({
           return undefined
 
         for (const def of variable.defs) {
+          // Imported bindings: we cannot statically resolve a cross-file
+          // initializer, but the developer named the imported identifier in
+          // the timeout position. Treat it as an explicit timeout so the
+          // rule does not flag the test.
+          if (def.type === 'ImportBinding') return 0
+
           if (def.type !== 'Variable') continue
 
           // only accept `const` bindings

tests/require-test-timeout.test.ts

@@ -36,6 +36,13 @@ ruleTester.run(RULE_NAME, rule, {
     // in-source unit tests
     'if (import.meta.vitest) { const opts = { timeout: 500 }; describe("outer", () => { it("repro: same-file opts object", opts, () => {}); }); }',
     'if (import.meta.vitest) { const T = 500; describe("outer", () => { describe("inner", () => { it("repro: same-file const timeout", () => {}, T); }); }); }',
+    // imported const used as the timeout argument (#892)
+    'import { TIMEOUT } from "./test-constants"; test("a", () => {}, TIMEOUT)',
+    'import { TIMEOUT } from "./test-constants"; it("a", () => {}, TIMEOUT)',
+    'import { TIMEOUT } from "./test-constants"; test("a", () => {}, { timeout: TIMEOUT })',
+    'import { TIMEOUT } from "./test-constants"; test("a", { timeout: TIMEOUT }, () => {})',
+    'import { OPTS } from "./test-constants"; test("a", OPTS, () => {})',
+    'import T from "./test-constants"; test("a", () => {}, T)',
   ],
   invalid: [
     {
@@ -135,5 +142,11 @@ ruleTester.run(RULE_NAME, rule, {
       code: 'test("a", () => {}, 1000, { timeout: -1 })',
       errors: [{ messageId: 'missingTimeout' }],
     },
+    // importing a binding does not bypass the rule when the import is not in
+    // the timeout position
+    {
+      code: 'import { TIMEOUT } from "./test-constants"; test("a", () => {})',
+      errors: [{ messageId: 'missingTimeout' }],
+    },
   ],
 })