onbuzz 3.6.1 → 3.6.2

package/src/analyzers/__tests__/SparrowAnalyzer.test.js

@@ -0,0 +1,270 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs/promises
+const mockAccess = jest.fn();
+const mockStat = jest.fn();
+jest.unstable_mockModule('fs/promises', () => ({
+  default: { access: mockAccess, stat: mockStat },
+  access: mockAccess,
+  stat: mockStat
+}));
+
+// Mock sparrow-sast
+const mockScan = jest.fn();
+const mockGetRegistry = jest.fn();
+const mockGetAllAnalyzers = jest.fn();
+jest.unstable_mockModule('sparrow-sast', () => ({
+  default: {
+    scan: mockScan,
+    getRegistry: mockGetRegistry,
+    getAllAnalyzers: mockGetAllAnalyzers,
+    Language: {
+      Python: 'python',
+      JavaScript: 'javascript',
+      TypeScript: 'typescript',
+      Go: 'go',
+      Java: 'java',
+      Ruby: 'ruby',
+      Rust: 'rust',
+      PHP: 'php',
+      CSharp: 'csharp',
+      Bash: 'bash',
+      HTML: 'html',
+      CSS: 'css'
+    }
+  },
+  scan: mockScan,
+  getRegistry: mockGetRegistry,
+  getAllAnalyzers: mockGetAllAnalyzers,
+  Language: {
+    Python: 'python',
+    JavaScript: 'javascript',
+    TypeScript: 'typescript'
+  }
+}));
+
+const { default: SparrowAnalyzer } = await import('../SparrowAnalyzer.js');
+
+describe('SparrowAnalyzer', () => {
+  let analyzer;
+  let logger;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    analyzer = new SparrowAnalyzer(logger);
+    analyzer.initialized = false;
+    analyzer.sparrow = null;
+    jest.clearAllMocks();
+  });
+
+  // ── Constructor ──
+  test('constructor initializes with defaults', () => {
+    expect(analyzer.logger).toBe(logger);
+    expect(analyzer.sparrow).toBeNull();
+    expect(analyzer.initialized).toBe(false);
+  });
+
+  // ── getSupportedLanguages ──
+  test('getSupportedLanguages returns all supported languages', () => {
+    const langs = analyzer.getSupportedLanguages();
+    expect(langs).toContain('python');
+    expect(langs).toContain('javascript');
+    expect(langs).toContain('typescript');
+    expect(langs).toContain('go');
+    expect(langs.length).toBe(12);
+  });
+
+  // ── getSupportedExtensions ──
+  test('getSupportedExtensions returns file extensions', () => {
+    const exts = analyzer.getSupportedExtensions();
+    expect(exts).toContain('.py');
+    expect(exts).toContain('.js');
+    expect(exts).toContain('.ts');
+    expect(exts).toContain('.go');
+  });
+
+  // ── isSupported ──
+  test('isSupported returns true for supported files', () => {
+    expect(analyzer.isSupported('test.py')).toBe(true);
+    expect(analyzer.isSupported('test.js')).toBe(true);
+    expect(analyzer.isSupported('test.ts')).toBe(true);
+    expect(analyzer.isSupported('test.go')).toBe(true);
+  });
+
+  test('isSupported returns false for unsupported files', () => {
+    expect(analyzer.isSupported('test.txt')).toBe(false);
+    expect(analyzer.isSupported('test.md')).toBe(false);
+  });
+
+  // ── ensureInitialized ──
+  test('ensureInitialized loads sparrow module', async () => {
+    await analyzer.ensureInitialized();
+    expect(analyzer.initialized).toBe(true);
+    expect(analyzer.sparrow).toBeDefined();
+  });
+
+  test('ensureInitialized skips if already initialized', async () => {
+    analyzer.initialized = true;
+    analyzer.sparrow = { scan: jest.fn() };
+    await analyzer.ensureInitialized();
+    // No error thrown
+  });
+
+  // ── transformIssue ──
+  test('transformIssue converts sparrow issue to standard format', () => {
+    const issue = {
+      id: 'SQL_INJECTION',
+      filepath: '/project/test.py',
+      range: { start: { row: 4, column: 0 }, end: { row: 4, column: 20 } },
+      severity: 'error',
+      category: 'security',
+      message: 'Possible SQL injection'
+    };
+
+    const result = analyzer.transformIssue(issue, '/project/test.py');
+    expect(result.id).toBe('SQL_INJECTION');
+    expect(result.line).toBe(5); // 0-based to 1-based
+    expect(result.column).toBe(1);
+    expect(result.endLine).toBe(5);
+    expect(result.severity).toBe('error');
+    expect(result.source).toBe('sparrow');
+    expect(result.fixable).toBe(false);
+  });
+
+  test('transformIssue handles missing range', () => {
+    const issue = {
+      id: 'TEST',
+      filepath: '/project/test.py',
+      message: 'Test issue'
+    };
+
+    const result = analyzer.transformIssue(issue, '/project/test.py');
+    expect(result.line).toBe(1);
+    expect(result.column).toBe(1);
+  });
+
+  // ── groupByCategory ──
+  test('groupByCategory groups issues correctly', () => {
+    const issues = [
+      { category: 'security' },
+      { category: 'security' },
+      { category: 'performance' },
+      { category: undefined }
+    ];
+    const groups = analyzer.groupByCategory(issues);
+    expect(groups.security).toBe(2);
+    expect(groups.performance).toBe(1);
+    expect(groups.other).toBe(1);
+  });
+
+  // ── groupByLanguage ──
+  test('groupByLanguage groups file results by language', () => {
+    const fileResults = [
+      { file: 'test.py', issues: [] },
+      { file: 'app.js', issues: [] },
+      { file: 'util.js', issues: [] },
+      { file: 'main.go', issues: [] }
+    ];
+    const groups = analyzer.groupByLanguage(fileResults);
+    expect(groups.python).toBe(1);
+    expect(groups.javascript).toBe(2);
+    expect(groups.go).toBe(1);
+  });
+
+  test('groupByLanguage maps unknown extensions to other', () => {
+    const fileResults = [{ file: 'readme.txt', issues: [] }];
+    const groups = analyzer.groupByLanguage(fileResults);
+    expect(groups.other).toBe(1);
+  });
+
+  // ── scanFile ──
+  test('scanFile returns skipped result for unsupported file', async () => {
+    mockAccess.mockResolvedValue(undefined);
+
+    const result = await analyzer.scanFile('/project/readme.txt');
+    expect(result.success).toBe(true);
+    expect(result.skipped).toBe(true);
+    expect(result.issues).toEqual([]);
+  });
+
+  test('scanFile returns issues for supported file', async () => {
+    mockAccess.mockResolvedValue(undefined);
+    mockScan.mockResolvedValue([
+      { id: 'XSS', filepath: '/project/test.js', message: 'XSS vulnerability', severity: 'error', category: 'security' }
+    ]);
+
+    const result = await analyzer.scanFile('/project/test.js');
+    expect(result.success).toBe(true);
+    expect(result.issues.length).toBe(1);
+    expect(result.summary.total).toBe(1);
+  });
+
+  test('scanFile handles scan errors', async () => {
+    mockAccess.mockRejectedValue(new Error('File not found'));
+
+    const result = await analyzer.scanFile('/project/test.js');
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  // ── scanProject ──
+  test('scanProject scans directory and returns grouped results', async () => {
+    mockStat.mockResolvedValue({ isDirectory: () => true });
+    mockScan.mockResolvedValue([
+      { id: 'XSS', filepath: '/project/app.js', message: 'XSS', severity: 'error', category: 'security' },
+      { id: 'SQLI', filepath: '/project/db.py', message: 'SQL injection', severity: 'critical', category: 'security' }
+    ]);
+
+    const result = await analyzer.scanProject('/project');
+    expect(result.success).toBe(true);
+    expect(result.isDirectory).toBe(true);
+    expect(result.files.length).toBe(2);
+    expect(result.summary.totalFiles).toBe(2);
+    expect(result.summary.totalIssues).toBe(2);
+  });
+
+  test('scanProject handles scan errors', async () => {
+    mockStat.mockRejectedValue(new Error('Path not found'));
+
+    const result = await analyzer.scanProject('/nonexistent');
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  test('scanProject applies language filter', async () => {
+    mockStat.mockResolvedValue({ isDirectory: () => true });
+    mockScan.mockResolvedValue([]);
+
+    const result = await analyzer.scanProject('/project', { languages: ['python', 'javascript'] });
+    expect(result.success).toBe(true);
+  });
+
+  // ── getCheckersInfo ──
+  test('getCheckersInfo returns analyzer info', async () => {
+    mockGetRegistry.mockReturnValue({});
+    mockGetAllAnalyzers.mockReturnValue([
+      { name: 'sql-injection', language: 'python', category: 'security', severity: 'error' }
+    ]);
+
+    const info = await analyzer.getCheckersInfo();
+    expect(info.length).toBe(1);
+    expect(info[0].name).toBe('sql-injection');
+  });
+
+  test('getCheckersInfo returns empty on error', async () => {
+    mockGetRegistry.mockReturnValue(null);
+
+    const info = await analyzer.getCheckersInfo();
+    expect(info).toEqual([]);
+  });
+
+  test('getCheckersInfo handles missing getRegistry', async () => {
+    // sparrow without getRegistry
+    analyzer.sparrow = {};
+    analyzer.initialized = true;
+
+    const info = await analyzer.getCheckersInfo();
+    expect(info).toEqual([]);
+  });
+});

package/src/analyzers/__tests__/TypeScriptAnalyzer.test.js

@@ -0,0 +1,187 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+import TypeScriptAnalyzer from '../TypeScriptAnalyzer.js';
+
+describe('TypeScriptAnalyzer', () => {
+  let analyzer;
+  let logger;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    analyzer = new TypeScriptAnalyzer(logger);
+  });
+
+  // ── Constructor ──
+  test('constructor sets logger and compiler options', () => {
+    expect(analyzer.logger).toBe(logger);
+    expect(analyzer.compilerOptions).toBeDefined();
+    expect(analyzer.compilerOptions.noEmit).toBe(true);
+    expect(analyzer.compilerOptions.strict).toBe(true);
+    expect(analyzer.compilerOptions.allowJs).toBe(false);
+  });
+
+  test('constructor works without logger', () => {
+    const a = new TypeScriptAnalyzer();
+    expect(a.logger).toBeNull();
+  });
+
+  // ── analyze ──
+  test('analyze returns empty array for valid TypeScript', async () => {
+    const content = 'const x: number = 42;\n';
+    const result = await analyzer.analyze('test.ts', content);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  test('analyze returns diagnostics for syntax errors', async () => {
+    const content = 'const x: number = ;\nfunction( { {{\n';
+    const result = await analyzer.analyze('broken.ts', content);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result[0]).toHaveProperty('severity');
+    expect(result[0]).toHaveProperty('message');
+    expect(result[0]).toHaveProperty('file');
+  });
+
+  test('analyze returns diagnostics with proper rule format', async () => {
+    const content = 'const x: number = "string";\n';
+    const result = await analyzer.analyze('types.ts', content);
+    // Should find type error or at least return an array
+    expect(Array.isArray(result)).toBe(true);
+    for (const diag of result) {
+      expect(diag.rule).toMatch(/^TS\d+$/);
+    }
+  });
+
+  test('analyze returns error diagnostic when analysis throws', async () => {
+    // Force an error by corrupting the analyzer
+    const badAnalyzer = new TypeScriptAnalyzer(logger);
+    badAnalyzer.compilerOptions = null; // Will cause createProgram to fail
+
+    const result = await badAnalyzer.analyze('test.ts', 'const x = 1;');
+    // Either returns normally or returns an error diagnostic
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  test('analyze handles empty content', async () => {
+    const result = await analyzer.analyze('empty.ts', '');
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  test('analyze handles TSX content', async () => {
+    const content = 'const el = <div>hello</div>;\n';
+    const result = await analyzer.analyze('component.tsx', content);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  // ── getSyntacticDiagnostics ──
+  test('getSyntacticDiagnostics returns empty for valid source', async () => {
+    const ts = (await import('typescript')).default;
+    const sourceFile = ts.createSourceFile('test.ts', 'const x = 1;', ts.ScriptTarget.Latest, true);
+    const result = analyzer.getSyntacticDiagnostics(sourceFile);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  // ── getSemanticDiagnostics ──
+  test('getSemanticDiagnostics returns array for valid content', async () => {
+    const result = await analyzer.getSemanticDiagnostics('test.ts', 'const x: number = 1;');
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  test('getSemanticDiagnostics detects type errors', async () => {
+    const content = 'const x: number = "hello";';
+    const result = await analyzer.getSemanticDiagnostics('types.ts', content);
+    expect(Array.isArray(result)).toBe(true);
+    // Should have at least one type error
+    if (result.length > 0) {
+      expect(result[0]).toHaveProperty('severity');
+    }
+  });
+
+  // ── formatDiagnostic ──
+  test('formatDiagnostic handles diagnostic with file and position', async () => {
+    const ts = (await import('typescript')).default;
+    const sourceFile = ts.createSourceFile('test.ts', 'const x = 1;\nconst y = 2;', ts.ScriptTarget.Latest, true);
+
+    const diagnostic = {
+      file: sourceFile,
+      start: 14, // position in source
+      category: ts.DiagnosticCategory.Error,
+      messageText: 'Test error message',
+      code: 2322
+    };
+
+    const result = analyzer.formatDiagnostic(diagnostic, sourceFile);
+    expect(result.line).toBeGreaterThan(0);
+    expect(result.column).toBeGreaterThan(0);
+    expect(result.severity).toBe('error');
+    expect(result.rule).toBe('TS2322');
+    expect(result.message).toBe('Test error message');
+  });
+
+  test('formatDiagnostic handles diagnostic without file', async () => {
+    const ts = (await import('typescript')).default;
+    const sourceFile = ts.createSourceFile('test.ts', 'const x = 1;', ts.ScriptTarget.Latest, true);
+
+    const diagnostic = {
+      start: 0,
+      category: ts.DiagnosticCategory.Warning,
+      messageText: 'Warning message',
+      code: 1000
+    };
+
+    const result = analyzer.formatDiagnostic(diagnostic, sourceFile);
+    expect(result.severity).toBe('warning');
+    expect(result.category).toBe('syntax'); // code 1000 is in syntax range
+  });
+
+  test('formatDiagnostic handles suggestion category', async () => {
+    const ts = (await import('typescript')).default;
+
+    const diagnostic = {
+      category: ts.DiagnosticCategory.Suggestion,
+      messageText: 'Suggestion',
+      code: 9999
+    };
+
+    const result = analyzer.formatDiagnostic(diagnostic, null);
+    expect(result.severity).toBe('info');
+  });
+
+  test('formatDiagnostic categorizes import errors by message', async () => {
+    const ts = (await import('typescript')).default;
+
+    const diagnostic = {
+      category: ts.DiagnosticCategory.Error,
+      messageText: 'Cannot find module "foo"',
+      code: 5000
+    };
+
+    const result = analyzer.formatDiagnostic(diagnostic, null);
+    expect(result.category).toBe('import');
+  });
+
+  test('formatDiagnostic categorizes type errors by code range', async () => {
+    const ts = (await import('typescript')).default;
+
+    const diagnostic = {
+      category: ts.DiagnosticCategory.Error,
+      messageText: 'Some error about assignment',
+      code: 2500
+    };
+
+    const result = analyzer.formatDiagnostic(diagnostic, null);
+    expect(result.category).toBe('type');
+  });
+
+  test('formatDiagnostic categorizes type errors by message content', async () => {
+    const ts = (await import('typescript')).default;
+
+    const diagnostic = {
+      category: ts.DiagnosticCategory.Error,
+      messageText: 'Property of type X',
+      code: 5000
+    };
+
+    const result = analyzer.formatDiagnostic(diagnostic, null);
+    expect(result.category).toBe('type');
+  });
+});