chore: improve getTsconfigWithContext test coverage

Author: JounQin

src/utils/export-map.ts

@@ -90,7 +90,7 @@ const parseComment = (comment: string): commentParser.Block => {
   }
 }
 
-function getTsconfigWithContext(context: ChildContext | RuleContext) {
+export function getTsconfigWithContext(context: ChildContext | RuleContext) {
   const parserOptions = context.parserOptions || {}
   let tsconfigRootDir = parserOptions.tsconfigRootDir
   const project = parserOptions.project
@@ -99,7 +99,11 @@ function getTsconfigWithContext(context: ChildContext | RuleContext) {
   if (tsconfigCache.has(cacheKey)) {
     tsConfig = tsconfigCache.get(cacheKey)!
   } else {
-    tsconfigRootDir = tsconfigRootDir || process.cwd()
+    tsconfigRootDir =
+      tsconfigRootDir ||
+      // TODO: uncomment in next major
+      // || context.cwd
+      process.cwd()
     let tsconfigResult: TsConfigResult | null | undefined
     if (project) {
       const projects = Array.isArray(project) ? project : [project]

test/utils/export-map.spec.ts

@@ -1,16 +1,23 @@
 import fs from 'node:fs'
+import path from 'node:path'
 import { setTimeout } from 'node:timers/promises'
 
 import { jest } from '@jest/globals'
 import * as getTsconfig from 'get-tsconfig'
 
-import { TEST_FILENAME, testFilePath } from '../utils.js'
+import {
+  FIXTURES_PATH,
+  TEST_FILENAME,
+  testContext,
+  testFilePath,
+} from '../utils.js'
 
 import type { ChildContext, RuleContext } from 'eslint-plugin-import-x'
 import {
   ExportMap,
   isMaybeUnambiguousModule,
 } from 'eslint-plugin-import-x/utils'
+import type { getTsconfigWithContext as getTsconfigWithContext_ } from 'eslint-plugin-import-x/utils'
 
 function jsdocTests(parseContext: ChildContext, lineEnding: string) {
   describe('deprecated imports', () => {
@@ -110,12 +117,18 @@ function jsdocTests(parseContext: ChildContext, lineEnding: string) {
   })
 }
 
+const createContext = (
+  parserOptions: RuleContext['languageOptions']['parserOptions'] = {},
+): RuleContext => ({
+  ...testContext(),
+  parserOptions,
+})
+
 describe('ExportMap', () => {
   const fakeContext = {
-    physicalFilename: TEST_FILENAME,
-    settings: {},
+    ...testContext(),
     parserPath: '@babel/eslint-parser',
-  } as RuleContext
+  }
 
   it('handles ExportAllDeclaration', () => {
     const imports = ExportMap.get('./export-all', fakeContext)!
@@ -514,4 +527,104 @@ describe('ExportMap', () => {
       })
     }
   })
+
+  describe('getTsconfigWithContext', () => {
+    let spied: jest.Mock
+
+    let getTsconfigWithContext: typeof getTsconfigWithContext_
+
+    const mockTsConfig: getTsconfig.TsConfigJsonResolved = {
+      compilerOptions: { esModuleInterop: true },
+    }
+
+    beforeEach(async () => {
+      jest.resetModules()
+      spied = jest.fn().mockReturnValue({ config: mockTsConfig })
+      jest.unstable_mockModule('get-tsconfig', () => ({
+        ...getTsconfig,
+        getTsconfig: spied,
+      }))
+      ;({ getTsconfigWithContext } = await import(
+        'eslint-plugin-import-x/utils'
+      ))
+    })
+
+    afterAll(() => {
+      spied.mockRestore()
+    })
+
+    test('caches and returns the result for the same context', () => {
+      // First call should use getTsconfig
+      const result1 = getTsconfigWithContext(fakeContext)
+      expect(spied).toHaveBeenCalledTimes(1)
+      expect(result1).toBe(mockTsConfig)
+
+      // Second call should use the cache
+      const result2 = getTsconfigWithContext(fakeContext)
+      expect(spied).toHaveBeenCalledTimes(1) // Still 1
+      expect(result2).toBe(mockTsConfig)
+    })
+
+    // TODO: enable in next major
+    test.skip('falls back to cwd when tsconfigRootDir is not provided', () => {
+      getTsconfigWithContext(fakeContext)
+      expect(spied).toHaveBeenCalledWith(FIXTURES_PATH)
+    })
+
+    test('uses tsconfigRootDir when provided', () => {
+      const tsconfigRootDir = '/custom/root/dir'
+      getTsconfigWithContext(createContext({ tsconfigRootDir }))
+      expect(spied).toHaveBeenCalledWith(tsconfigRootDir)
+    })
+
+    test('resolves single project string path', () => {
+      const tsconfigRootDir = '/custom/root/dir'
+      const project = 'tsconfig.custom.json'
+      getTsconfigWithContext(createContext({ tsconfigRootDir, project }))
+      expect(spied).toHaveBeenCalledWith(path.resolve(tsconfigRootDir, project))
+    })
+
+    test('uses physicalFilename when project is true', () => {
+      const context = createContext({ project: true })
+      getTsconfigWithContext(context)
+      expect(spied).toHaveBeenCalledWith(TEST_FILENAME)
+    })
+
+    test('tries multiple projects until finding a valid one', () => {
+      const tsconfigRootDir = '/custom/root/dir'
+      const projects = ['invalid.json', 'also-invalid.json', 'valid.json']
+      const context = createContext({ tsconfigRootDir, project: projects })
+
+      // Mock first two calls to return null (not found)
+      spied
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce(null)
+        .mockReturnValueOnce({ config: mockTsConfig })
+
+      const result = getTsconfigWithContext(context)
+
+      // Should have tried all three paths
+      expect(spied).toHaveBeenNthCalledWith(
+        1,
+        path.resolve(tsconfigRootDir, projects[0]),
+      )
+      expect(spied).toHaveBeenNthCalledWith(
+        2,
+        path.resolve(tsconfigRootDir, projects[1]),
+      )
+      expect(spied).toHaveBeenNthCalledWith(
+        3,
+        path.resolve(tsconfigRootDir, projects[2]),
+      )
+
+      expect(result).toBe(mockTsConfig)
+    })
+
+    test('returns undefined when no tsconfig is found', () => {
+      // Mock getTsconfig to return null (not found)
+      spied.mockReturnValue(null)
+      const result = getTsconfigWithContext(fakeContext)
+      expect(result).toBeUndefined()
+    })
+  })
 })