Upgrade test to work on windows. (#4815)

2 files changed, 75 insertions, 78 deletions

diff --git a/packages/core/src/utils/gitIgnoreParser.test.ts b/packages/core/src/utils/gitIgnoreParser.test.ts
index d94a7bfa..b5fe8b2a 100644
--- a/packages/core/src/utils/gitIgnoreParser.test.ts
+++ b/packages/core/src/utils/gitIgnoreParser.test.ts
@@ -4,39 +4,43 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { GitIgnoreParser } from './gitIgnoreParser.js';
-import * as fs from 'fs';
+import * as fs from 'fs/promises';
 import * as path from 'path';
-import { isGitRepository } from './gitUtils.js';
-
-// Mock fs module
-vi.mock('fs');
-
-// Mock gitUtils module
-vi.mock('./gitUtils.js');
+import * as os from 'os';
 
 describe('GitIgnoreParser', () => {
   let parser: GitIgnoreParser;
-  const mockProjectRoot = '/test/project';
+  let projectRoot: string;
+
+  async function createTestFile(filePath: string, content = '') {
+    const fullPath = path.join(projectRoot, filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content);
+  }
 
-  beforeEach(() => {
-    parser = new GitIgnoreParser(mockProjectRoot);
-    // Reset mocks before each test
-    vi.mocked(fs.readFileSync).mockClear();
-    vi.mocked(isGitRepository).mockReturnValue(true);
+  async function setupGitRepo() {
+    await fs.mkdir(path.join(projectRoot, '.git'), { recursive: true });
+  }
+
+  beforeEach(async () => {
+    projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitignore-test-'));
+    parser = new GitIgnoreParser(projectRoot);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
+  afterEach(async () => {
+    await fs.rm(projectRoot, { recursive: true, force: true });
   });
 
   describe('initialization', () => {
-    it('should initialize without errors when no .gitignore exists', () => {
+    it('should initialize without errors when no .gitignore exists', async () => {
+      await setupGitRepo();
       expect(() => parser.loadGitRepoPatterns()).not.toThrow();
     });
 
-    it('should load .gitignore patterns when file exists', () => {
+    it('should load .gitignore patterns when file exists', async () => {
+      await setupGitRepo();
       const gitignoreContent = `
 # Comment
 node_modules/
@@ -44,7 +48,7 @@ node_modules/
 /dist
 .env
 `;
-      vi.mocked(fs.readFileSync).mockReturnValueOnce(gitignoreContent);
+      await createTestFile('.gitignore', gitignoreContent);
 
       parser.loadGitRepoPatterns();
 
@@ -55,41 +59,35 @@ node_modules/
         '/dist',
         '.env',
       ]);
-      expect(parser.isIgnored('node_modules/some-lib')).toBe(true);
-      expect(parser.isIgnored('src/app.log')).toBe(true);
-      expect(parser.isIgnored('dist/index.js')).toBe(true);
+      expect(parser.isIgnored(path.join('node_modules', 'some-lib'))).toBe(
+        true,
+      );
+      expect(parser.isIgnored(path.join('src', 'app.log'))).toBe(true);
+      expect(parser.isIgnored(path.join('dist', 'index.js'))).toBe(true);
       expect(parser.isIgnored('.env')).toBe(true);
     });
 
-    it('should handle git exclude file', () => {
-      vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
-        if (
-          filePath === path.join(mockProjectRoot, '.git', 'info', 'exclude')
-        ) {
-          return 'temp/\n*.tmp';
-        }
-        throw new Error('ENOENT');
-      });
+    it('should handle git exclude file', async () => {
+      await setupGitRepo();
+      await createTestFile(
+        path.join('.git', 'info', 'exclude'),
+        'temp/\n*.tmp',
+      );
 
       parser.loadGitRepoPatterns();
       expect(parser.getPatterns()).toEqual(['.git', 'temp/', '*.tmp']);
-      expect(parser.isIgnored('temp/file.txt')).toBe(true);
-      expect(parser.isIgnored('src/file.tmp')).toBe(true);
+      expect(parser.isIgnored(path.join('temp', 'file.txt'))).toBe(true);
+      expect(parser.isIgnored(path.join('src', 'file.tmp'))).toBe(true);
     });
 
-    it('should handle custom patterns file name', () => {
-      vi.mocked(isGitRepository).mockReturnValue(false);
-      vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
-        if (filePath === path.join(mockProjectRoot, '.geminiignore')) {
-          return 'temp/\n*.tmp';
-        }
-        throw new Error('ENOENT');
-      });
+    it('should handle custom patterns file name', async () => {
+      // No .git directory for this test
+      await createTestFile('.geminiignore', 'temp/\n*.tmp');
 
       parser.loadPatterns('.geminiignore');
       expect(parser.getPatterns()).toEqual(['temp/', '*.tmp']);
-      expect(parser.isIgnored('temp/file.txt')).toBe(true);
-      expect(parser.isIgnored('src/file.tmp')).toBe(true);
+      expect(parser.isIgnored(path.join('temp', 'file.txt'))).toBe(true);
+      expect(parser.isIgnored(path.join('src', 'file.tmp'))).toBe(true);
     });
 
     it('should initialize without errors when no .geminiignore exists', () => {
@@ -98,7 +96,8 @@ node_modules/
   });
 
   describe('isIgnored', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
+      await setupGitRepo();
       const gitignoreContent = `
 node_modules/
 *.log
@@ -107,59 +106,65 @@ node_modules/
 src/*.tmp
 !src/important.tmp
 `;
-      vi.mocked(fs.readFileSync).mockReturnValueOnce(gitignoreContent);
+      await createTestFile('.gitignore', gitignoreContent);
       parser.loadGitRepoPatterns();
     });
 
     it('should always ignore .git directory', () => {
       expect(parser.isIgnored('.git')).toBe(true);
-      expect(parser.isIgnored('.git/config')).toBe(true);
-      expect(parser.isIgnored(path.join(mockProjectRoot, '.git', 'HEAD'))).toBe(
+      expect(parser.isIgnored(path.join('.git', 'config'))).toBe(true);
+      expect(parser.isIgnored(path.join(projectRoot, '.git', 'HEAD'))).toBe(
         true,
       );
     });
 
     it('should ignore files matching patterns', () => {
-      expect(parser.isIgnored('node_modules/package/index.js')).toBe(true);
+      expect(
+        parser.isIgnored(path.join('node_modules', 'package', 'index.js')),
+      ).toBe(true);
       expect(parser.isIgnored('app.log')).toBe(true);
-      expect(parser.isIgnored('logs/app.log')).toBe(true);
-      expect(parser.isIgnored('dist/bundle.js')).toBe(true);
+      expect(parser.isIgnored(path.join('logs', 'app.log'))).toBe(true);
+      expect(parser.isIgnored(path.join('dist', 'bundle.js'))).toBe(true);
       expect(parser.isIgnored('.env')).toBe(true);
-      expect(parser.isIgnored('config/.env')).toBe(false); // .env is anchored to root
+      expect(parser.isIgnored(path.join('config', '.env'))).toBe(false); // .env is anchored to root
     });
 
     it('should ignore files with path-specific patterns', () => {
-      expect(parser.isIgnored('src/temp.tmp')).toBe(true);
-      expect(parser.isIgnored('other/temp.tmp')).toBe(false);
+      expect(parser.isIgnored(path.join('src', 'temp.tmp'))).toBe(true);
+      expect(parser.isIgnored(path.join('other', 'temp.tmp'))).toBe(false);
     });
 
     it('should handle negation patterns', () => {
-      expect(parser.isIgnored('src/important.tmp')).toBe(false);
+      expect(parser.isIgnored(path.join('src', 'important.tmp'))).toBe(false);
     });
 
     it('should not ignore files that do not match patterns', () => {
-      expect(parser.isIgnored('src/index.ts')).toBe(false);
+      expect(parser.isIgnored(path.join('src', 'index.ts'))).toBe(false);
       expect(parser.isIgnored('README.md')).toBe(false);
     });
 
     it('should handle absolute paths correctly', () => {
-      const absolutePath = path.join(mockProjectRoot, 'node_modules', 'lib');
+      const absolutePath = path.join(projectRoot, 'node_modules', 'lib');
       expect(parser.isIgnored(absolutePath)).toBe(true);
     });
 
     it('should handle paths outside project root by not ignoring them', () => {
-      const outsidePath = path.resolve(mockProjectRoot, '../other/file.txt');
+      const outsidePath = path.resolve(projectRoot, '..', 'other', 'file.txt');
       expect(parser.isIgnored(outsidePath)).toBe(false);
     });
 
     it('should handle relative paths correctly', () => {
-      expect(parser.isIgnored('node_modules/some-package')).toBe(true);
-      expect(parser.isIgnored('../some/other/file.txt')).toBe(false);
+      expect(parser.isIgnored(path.join('node_modules', 'some-package'))).toBe(
+        true,
+      );
+      expect(
+        parser.isIgnored(path.join('..', 'some', 'other', 'file.txt')),
+      ).toBe(false);
     });
 
     it('should normalize path separators on Windows', () => {
-      expect(parser.isIgnored('node_modules\\package')).toBe(true);
-      expect(parser.isIgnored('src\\temp.tmp')).toBe(true);
+      expect(parser.isIgnored(path.join('node_modules', 'package'))).toBe(true);
+      expect(parser.isIgnored(path.join('src', 'temp.tmp'))).toBe(true);
     });
 
     it('should handle root path "/" without throwing error', () => {
@@ -179,9 +184,10 @@ src/*.tmp
   });
 
   describe('getIgnoredPatterns', () => {
-    it('should return the raw patterns added', () => {
+    it('should return the raw patterns added', async () => {
+      await setupGitRepo();
       const gitignoreContent = '*.log\n!important.log';
-      vi.mocked(fs.readFileSync).mockReturnValueOnce(gitignoreContent);
+      await createTestFile('.gitignore', gitignoreContent);
 
       parser.loadGitRepoPatterns();
       expect(parser.getPatterns()).toEqual(['.git', '*.log', '!important.log']);
diff --git a/packages/core/src/utils/gitIgnoreParser.ts b/packages/core/src/utils/gitIgnoreParser.ts
index 50018bb7..f2422a92 100644
--- a/packages/core/src/utils/gitIgnoreParser.ts
+++ b/packages/core/src/utils/gitIgnoreParser.ts
@@ -57,24 +57,15 @@ export class GitIgnoreParser implements GitIgnoreFilter {
   }
 
   isIgnored(filePath: string): boolean {
-    const relativePath = path.isAbsolute(filePath)
-      ? path.relative(this.projectRoot, filePath)
-      : filePath;
+    const resolved = path.resolve(this.projectRoot, filePath);
+    const relativePath = path.relative(this.projectRoot, resolved);
 
-    if (
-      relativePath === '' ||
-      relativePath.startsWith('..') ||
-      relativePath === '/' ||
-      relativePath.startsWith('/')
-    ) {
+    if (relativePath === '' || relativePath.startsWith('..')) {
       return false;
     }
 
-    let normalizedPath = relativePath.replace(/\\/g, '/');
-    if (normalizedPath.startsWith('./')) {
-      normalizedPath = normalizedPath.substring(2);
-    }
-
+    // Even in windows, Ignore expects forward slashes.
+    const normalizedPath = relativePath.replace(/\\/g, '/');
     return this.ig.ignores(normalizedPath);
   }