[autofix.ci] apply automated fixes

Author: autofix-ci[bot]

tests/unit/context-aware.spec.ts

@@ -3,7 +3,7 @@ import type { ResolvedResult } from 'eslint-import-context'
 
 vi.mock('eslint-import-context', () => {
   let mockContext: { cwd?: string } | null = null
-  
+
   return {
     useRuleContext: vi.fn(() => mockContext),
     __setMockContext: (context: { cwd?: string } | null) => {
@@ -13,10 +13,13 @@ vi.mock('eslint-import-context', () => {
   }
 })
 
-import { resolve, createTypeScriptImportResolver } from 'eslint-import-resolver-typescript'
+import {
+  resolve,
+  createTypeScriptImportResolver,
+} from 'eslint-import-resolver-typescript'
 import { useRuleContext } from 'eslint-import-context'
 
-const mockModule = await import('eslint-import-context') as any
+const mockModule = (await import('eslint-import-context')) as any
 
 describe('Context-aware import resolution', () => {
   const originalCwd = process.cwd()
@@ -34,40 +37,58 @@ describe('Context-aware import resolution', () => {
 
   describe('Dynamic cwd resolution', () => {
     it('should use context.cwd when available', () => {
-      const mockResolve = vi.fn().mockReturnValue({ found: false } as ResolvedResult)
-      const mockResolverFactory = vi.fn().mockImplementation(() => ({ sync: mockResolve }))
-      vi.doMock('unrs-resolver', () => ({ ResolverFactory: mockResolverFactory }))
+      const mockResolve = vi
+        .fn()
+        .mockReturnValue({ found: false } as ResolvedResult)
+      const mockResolverFactory = vi
+        .fn()
+        .mockImplementation(() => ({ sync: mockResolve }))
+      vi.doMock('unrs-resolver', () => ({
+        ResolverFactory: mockResolverFactory,
+      }))
 
       mockModule.__setMockContext({ cwd: testCwd1 })
-      
+
       resolve('some-module', '/test/file.ts', {})
-      
+
       expect(useRuleContext).toHaveBeenCalled()
       expect(mockResolve).toHaveBeenCalled()
     })
 
     it('should fallback to process.cwd() when context is null', () => {
-      const mockResolve = vi.fn().mockReturnValue({ found: false } as ResolvedResult)
-      const mockResolverFactory = vi.fn().mockImplementation(() => ({ sync: mockResolve }))
-      vi.doMock('unrs-resolver', () => ({ ResolverFactory: mockResolverFactory }))
+      const mockResolve = vi
+        .fn()
+        .mockReturnValue({ found: false } as ResolvedResult)
+      const mockResolverFactory = vi
+        .fn()
+        .mockImplementation(() => ({ sync: mockResolve }))
+      vi.doMock('unrs-resolver', () => ({
+        ResolverFactory: mockResolverFactory,
+      }))
 
       mockModule.__setMockContext(null)
-      
+
       resolve('some-module', '/test/file.ts', {})
-      
+
       expect(useRuleContext).toHaveBeenCalled()
       expect(mockResolve).toHaveBeenCalled()
     })
 
     it('should fallback to process.cwd() when context.cwd is undefined', () => {
-      const mockResolve = vi.fn().mockReturnValue({ found: false } as ResolvedResult)
-      const mockResolverFactory = vi.fn().mockImplementation(() => ({ sync: mockResolve }))
-      vi.doMock('unrs-resolver', () => ({ ResolverFactory: mockResolverFactory }))
+      const mockResolve = vi
+        .fn()
+        .mockReturnValue({ found: false } as ResolvedResult)
+      const mockResolverFactory = vi
+        .fn()
+        .mockImplementation(() => ({ sync: mockResolve }))
+      vi.doMock('unrs-resolver', () => ({
+        ResolverFactory: mockResolverFactory,
+      }))
 
       mockModule.__setMockContext({})
-      
+
       resolve('some-module', '/test/file.ts', {})
-      
+
       expect(useRuleContext).toHaveBeenCalled()
       expect(mockResolve).toHaveBeenCalled()
     })
@@ -78,49 +99,49 @@ describe('Context-aware import resolution', () => {
       const mockResolverFactory = vi.fn()
       vi.doMock('unrs-resolver', () => ({
         ResolverFactory: mockResolverFactory.mockImplementation(() => ({
-          sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult)
-        }))
+          sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult),
+        })),
       }))
 
       mockModule.__setMockContext({ cwd: testCwd1 })
-      
+
       resolve('some-module', '/test/file.ts', {})
-      
+
       expect(mockResolverFactory).toHaveBeenCalledTimes(1)
     })
 
     it('should create separate cache entries for different cwd values', () => {
       const mockResolverFactory = vi.fn()
       vi.doMock('unrs-resolver', () => ({
         ResolverFactory: mockResolverFactory.mockImplementation(() => ({
-          sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult)
-        }))
+          sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult),
+        })),
       }))
 
       // First resolution with testCwd1
       mockModule.__setMockContext({ cwd: testCwd1 })
       resolve('some-module', '/test/file.ts', {})
-      
+
       // Second resolution with testCwd2 should create new resolver
       mockModule.__setMockContext({ cwd: testCwd2 })
       resolve('some-module', '/test/file.ts', {})
-      
+
       expect(mockResolverFactory).toHaveBeenCalledTimes(2)
     })
 
     it('should reuse cache for same cwd and options', () => {
       const mockResolverFactory = vi.fn()
       vi.doMock('unrs-resolver', () => ({
         ResolverFactory: mockResolverFactory.mockImplementation(() => ({
-          sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult)
-        }))
+          sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult),
+        })),
       }))
 
       mockModule.__setMockContext({ cwd: testCwd1 })
-      
+
       resolve('some-module', '/test/file1.ts', {})
       resolve('another-module', '/test/file2.ts', {})
-      
+
       expect(mockResolverFactory).toHaveBeenCalledTimes(1)
     })
   })
@@ -129,75 +150,87 @@ describe('Context-aware import resolution', () => {
     it('should update cwd and recreate resolver when context changes', () => {
       const mockResolverFactory = vi.fn()
       const mockCloneWithOptions = vi.fn()
-      
+
       const mockResolver = {
         sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult),
-        cloneWithOptions: mockCloneWithOptions
+        cloneWithOptions: mockCloneWithOptions,
       }
-      
+
       vi.doMock('unrs-resolver', () => ({
-        ResolverFactory: mockResolverFactory.mockImplementation(() => mockResolver)
+        ResolverFactory: mockResolverFactory.mockImplementation(
+          () => mockResolver,
+        ),
       }))
 
       mockModule.__setMockContext(null)
-      const resolver = createTypeScriptImportResolver({ project: ['./tsconfig.json'] })
-      
+      const resolver = createTypeScriptImportResolver({
+        project: ['./tsconfig.json'],
+      })
+
       resolver.resolve('some-module', '/test/file.ts')
-      
+
       mockModule.__setMockContext({ cwd: testCwd1 })
       resolver.resolve('another-module', '/test/file.ts')
-      
+
       expect(useRuleContext).toHaveBeenCalledTimes(2)
       expect(mockCloneWithOptions).toHaveBeenCalled()
     })
 
     it('should create new resolver when no existing resolver and context changes', () => {
       const mockResolverFactory = vi.fn()
-      
+
       const mockResolver = {
-        sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult)
+        sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult),
       }
-      
+
       vi.doMock('unrs-resolver', () => ({
-        ResolverFactory: mockResolverFactory.mockImplementation(() => mockResolver)
+        ResolverFactory: mockResolverFactory.mockImplementation(
+          () => mockResolver,
+        ),
       }))
 
       mockModule.__setMockContext(null)
-      const resolver = createTypeScriptImportResolver({ project: ['./tsconfig.json'] })
-      
+      const resolver = createTypeScriptImportResolver({
+        project: ['./tsconfig.json'],
+      })
+
       mockModule.__setMockContext({ cwd: testCwd1 })
       resolver.resolve('some-module', '/test/file.ts')
-      
+
       expect(mockResolverFactory).toHaveBeenCalled()
     })
 
     it('should not recreate resolver when cwd remains the same', () => {
       const mockResolverFactory = vi.fn()
       const mockCloneWithOptions = vi.fn()
-      
+
       const mockResolver = {
         sync: vi.fn().mockReturnValue({ found: false } as ResolvedResult),
-        cloneWithOptions: mockCloneWithOptions
+        cloneWithOptions: mockCloneWithOptions,
       }
-      
+
       vi.doMock('unrs-resolver', () => ({
-        ResolverFactory: mockResolverFactory.mockImplementation(() => mockResolver)
+        ResolverFactory: mockResolverFactory.mockImplementation(
+          () => mockResolver,
+        ),
       }))
 
       mockModule.__setMockContext({ cwd: testCwd1 })
-      const resolver = createTypeScriptImportResolver({ project: ['./tsconfig.json'] })
-      
+      const resolver = createTypeScriptImportResolver({
+        project: ['./tsconfig.json'],
+      })
+
       resolver.resolve('some-module', '/test/file1.ts')
       resolver.resolve('another-module', '/test/file2.ts')
-      
+
       expect(useRuleContext).toHaveBeenCalledTimes(2)
       expect(mockCloneWithOptions).not.toHaveBeenCalled()
     })
 
     it('should handle interfaceVersion and name properties correctly', () => {
       mockModule.__setMockContext(null)
       const resolver = createTypeScriptImportResolver()
-      
+
       expect(resolver.interfaceVersion).toBe(3)
       expect(resolver.name).toBe('eslint-import-resolver-typescript')
     })
@@ -206,18 +239,18 @@ describe('Context-aware import resolution', () => {
   describe('Function signature compatibility', () => {
     it('should handle optional parameters correctly in resolve function', () => {
       mockModule.__setMockContext({ cwd: testCwd1 })
-      
+
       expect(() => resolve('module', '/file.ts', {}, null)).not.toThrow()
       expect(() => resolve('module', '/file.ts')).not.toThrow()
       expect(() => resolve('module', '/file.ts', undefined)).not.toThrow()
     })
 
     it('should handle optional parameters correctly in createTypeScriptImportResolver', () => {
       mockModule.__setMockContext(null)
-      
+
       expect(() => createTypeScriptImportResolver({})).not.toThrow()
       expect(() => createTypeScriptImportResolver()).not.toThrow()
       expect(() => createTypeScriptImportResolver(null)).not.toThrow()
     })
   })
-})
+})