abbyswag/qwen-code
1
0
Fork 0
mirror of https://github.com/QwenLM/qwen-code.git synced 2025-12-19 09:33:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Upgrade test to work on windows. (#4815)

Browse Source
This commit is contained in:
Tommaso Sciortino
2025-07-25 00:15:41 -07:00
committed by GitHub
parent 1d7eb0d250
commit 5d4b02ca85
2 changed files with 75 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
packages/core/src/utils/gitIgnoreParser.test.ts
View File

@@ -4,39 +4,43 @@
* SPDX-License-Identifier: Apache-2.0 * 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 { GitIgnoreParser } from './gitIgnoreParser.js';
import * as fs from 'fs'; import * as fs from 'fs/promises';
import * as path from 'path'; import * as path from 'path';
import { isGitRepository } from './gitUtils.js'; import * as os from 'os';
// Mock fs module
vi.mock('fs');
// Mock gitUtils module
vi.mock('./gitUtils.js');
describe('GitIgnoreParser', () => { describe('GitIgnoreParser', () => {
let parser: GitIgnoreParser; let parser: GitIgnoreParser;
const mockProjectRoot = '/test/project'; let projectRoot: string;
beforeEach(() => { async function createTestFile(filePath: string, content = '') {
parser = new GitIgnoreParser(mockProjectRoot); const fullPath = path.join(projectRoot, filePath);
// Reset mocks before each test await fs.mkdir(path.dirname(fullPath), { recursive: true });
vi.mocked(fs.readFileSync).mockClear(); await fs.writeFile(fullPath, content);
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(() => { afterEach(async () => {
vi.restoreAllMocks(); await fs.rm(projectRoot, { recursive: true, force: true });
}); });
describe('initialization', () => { 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(); 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 = ` const gitignoreContent = `
# Comment # Comment
node_modules/ node_modules/
@@ -44,7 +48,7 @@ node_modules/
/dist /dist
.env .env
`; `;
vi.mocked(fs.readFileSync).mockReturnValueOnce(gitignoreContent); await createTestFile('.gitignore', gitignoreContent);
parser.loadGitRepoPatterns(); parser.loadGitRepoPatterns();
@@ -55,41 +59,35 @@ node_modules/
'/dist', '/dist',
'.env', '.env',
]); ]);
expect(parser.isIgnored('node_modules/some-lib')).toBe(true); expect(parser.isIgnored(path.join('node_modules', 'some-lib'))).toBe(
expect(parser.isIgnored('src/app.log')).toBe(true); true,
expect(parser.isIgnored('dist/index.js')).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); expect(parser.isIgnored('.env')).toBe(true);
}); });
it('should handle git exclude file', () => { it('should handle git exclude file', async () => {
vi.mocked(fs.readFileSync).mockImplementation((filePath) => { await setupGitRepo();
if ( await createTestFile(
filePath === path.join(mockProjectRoot, '.git', 'info', 'exclude') path.join('.git', 'info', 'exclude'),
) { 'temp/\n*.tmp',
return 'temp/\n*.tmp'; );
}
throw new Error('ENOENT');
});
parser.loadGitRepoPatterns(); parser.loadGitRepoPatterns();
expect(parser.getPatterns()).toEqual(['.git', 'temp/', '*.tmp']); expect(parser.getPatterns()).toEqual(['.git', 'temp/', '*.tmp']);
expect(parser.isIgnored('temp/file.txt')).toBe(true); expect(parser.isIgnored(path.join('temp', 'file.txt'))).toBe(true);
expect(parser.isIgnored('src/file.tmp')).toBe(true); expect(parser.isIgnored(path.join('src', 'file.tmp'))).toBe(true);
}); });
it('should handle custom patterns file name', () => { it('should handle custom patterns file name', async () => {
vi.mocked(isGitRepository).mockReturnValue(false); // No .git directory for this test
vi.mocked(fs.readFileSync).mockImplementation((filePath) => { await createTestFile('.geminiignore', 'temp/\n*.tmp');
if (filePath === path.join(mockProjectRoot, '.geminiignore')) {
return 'temp/\n*.tmp';
}
throw new Error('ENOENT');
});
parser.loadPatterns('.geminiignore'); parser.loadPatterns('.geminiignore');
expect(parser.getPatterns()).toEqual(['temp/', '*.tmp']); expect(parser.getPatterns()).toEqual(['temp/', '*.tmp']);
expect(parser.isIgnored('temp/file.txt')).toBe(true); expect(parser.isIgnored(path.join('temp', 'file.txt'))).toBe(true);
expect(parser.isIgnored('src/file.tmp')).toBe(true); expect(parser.isIgnored(path.join('src', 'file.tmp'))).toBe(true);
}); });
it('should initialize without errors when no .geminiignore exists', () => { it('should initialize without errors when no .geminiignore exists', () => {
@@ -98,7 +96,8 @@ node_modules/
}); });
describe('isIgnored', () => { describe('isIgnored', () => {
beforeEach(() => { beforeEach(async () => {
await setupGitRepo();
const gitignoreContent = ` const gitignoreContent = `
node_modules/ node_modules/
*.log *.log
@@ -107,59 +106,65 @@ node_modules/
src/*.tmp src/*.tmp
!src/important.tmp !src/important.tmp
`; `;
vi.mocked(fs.readFileSync).mockReturnValueOnce(gitignoreContent); await createTestFile('.gitignore', gitignoreContent);
parser.loadGitRepoPatterns(); parser.loadGitRepoPatterns();
}); });
it('should always ignore .git directory', () => { it('should always ignore .git directory', () => {
expect(parser.isIgnored('.git')).toBe(true); expect(parser.isIgnored('.git')).toBe(true);
expect(parser.isIgnored('.git/config')).toBe(true); expect(parser.isIgnored(path.join('.git', 'config'))).toBe(true);
expect(parser.isIgnored(path.join(mockProjectRoot, '.git', 'HEAD'))).toBe( expect(parser.isIgnored(path.join(projectRoot, '.git', 'HEAD'))).toBe(
true, true,
); );
}); });
it('should ignore files matching patterns', () => { 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('app.log')).toBe(true);
expect(parser.isIgnored('logs/app.log')).toBe(true); expect(parser.isIgnored(path.join('logs', 'app.log'))).toBe(true);
expect(parser.isIgnored('dist/bundle.js')).toBe(true); expect(parser.isIgnored(path.join('dist', 'bundle.js'))).toBe(true);
expect(parser.isIgnored('.env')).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', () => { it('should ignore files with path-specific patterns', () => {
expect(parser.isIgnored('src/temp.tmp')).toBe(true); expect(parser.isIgnored(path.join('src', 'temp.tmp'))).toBe(true);
expect(parser.isIgnored('other/temp.tmp')).toBe(false); expect(parser.isIgnored(path.join('other', 'temp.tmp'))).toBe(false);
}); });
it('should handle negation patterns', () => { 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', () => { 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); expect(parser.isIgnored('README.md')).toBe(false);
}); });
it('should handle absolute paths correctly', () => { 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); expect(parser.isIgnored(absolutePath)).toBe(true);
}); });
it('should handle paths outside project root by not ignoring them', () => { 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); expect(parser.isIgnored(outsidePath)).toBe(false);
}); });
it('should handle relative paths correctly', () => { it('should handle relative paths correctly', () => {
expect(parser.isIgnored('node_modules/some-package')).toBe(true); expect(parser.isIgnored(path.join('node_modules', 'some-package'))).toBe(
expect(parser.isIgnored('../some/other/file.txt')).toBe(false); true,
);
expect(
parser.isIgnored(path.join('..', 'some', 'other', 'file.txt')),
).toBe(false);
}); });
it('should normalize path separators on Windows', () => { it('should normalize path separators on Windows', () => {
expect(parser.isIgnored('node_modules\\package')).toBe(true); expect(parser.isIgnored(path.join('node_modules', 'package'))).toBe(true);
expect(parser.isIgnored('src\\temp.tmp')).toBe(true); expect(parser.isIgnored(path.join('src', 'temp.tmp'))).toBe(true);
}); });
it('should handle root path "/" without throwing error', () => { it('should handle root path "/" without throwing error', () => {
@@ -179,9 +184,10 @@ src/*.tmp
}); });
describe('getIgnoredPatterns', () => { 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'; const gitignoreContent = '*.log\n!important.log';
vi.mocked(fs.readFileSync).mockReturnValueOnce(gitignoreContent); await createTestFile('.gitignore', gitignoreContent);
parser.loadGitRepoPatterns(); parser.loadGitRepoPatterns();
expect(parser.getPatterns()).toEqual(['.git', '*.log', '!important.log']); expect(parser.getPatterns()).toEqual(['.git', '*.log', '!important.log']);

19
packages/core/src/utils/gitIgnoreParser.ts
View File

@@ -57,24 +57,15 @@ export class GitIgnoreParser implements GitIgnoreFilter {
} }
isIgnored(filePath: string): boolean { isIgnored(filePath: string): boolean {
const relativePath = path.isAbsolute(filePath) const resolved = path.resolve(this.projectRoot, filePath);
? path.relative(this.projectRoot, filePath) const relativePath = path.relative(this.projectRoot, resolved);
: filePath;
if ( if (relativePath === '' || relativePath.startsWith('..')) {
relativePath === '' ||
relativePath.startsWith('..') ||
relativePath === '/' ||
relativePath.startsWith('/')
) {
return false; return false;
} }
let normalizedPath = relativePath.replace(/\\/g, '/'); // Even in windows, Ignore expects forward slashes.
if (normalizedPath.startsWith('./')) { const normalizedPath = relativePath.replace(/\\/g, '/');
normalizedPath = normalizedPath.substring(2);
}
return this.ig.ignores(normalizedPath); return this.ig.ignores(normalizedPath);
} }