qa360 2.2.1 → 2.2.13

package/core/src/generation/__tests__/source-analyzer.test.ts

@@ -1,774 +0,0 @@
-/**
- * Tests for Source Analyzer
- *
- * Tests for source code analysis and test generation suggestions.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  SourceAnalyzer,
-  analyzeSourceFile,
-  analyzeSourceDirectory,
-  generateTestSpec,
-  type SourceAnalysis,
-  type SourceAnalyzerOptions
-} from '../source-analyzer.js';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-
-describe('SourceAnalyzer', () => {
-  let analyzer: SourceAnalyzer;
-  let testDir: string;
-
-  beforeEach(() => {
-    analyzer = new SourceAnalyzer();
-    testDir = join(process.cwd(), '.tmp-test-source-analyzer');
-  });
-
-  afterEach(() => {
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('Constructor', () => {
-    it('should create analyzer with default options', () => {
-      expect(analyzer).toBeInstanceOf(SourceAnalyzer);
-    });
-
-    it('should accept custom options', () => {
-      const options: SourceAnalyzerOptions = {
-        includePrivate: true,
-        maxComplexity: 5,
-        exclude: ['test', 'spec'],
-        followImports: true
-      };
-
-      const customAnalyzer = new SourceAnalyzer(options);
-      expect(customAnalyzer).toBeInstanceOf(SourceAnalyzer);
-    });
-  });
-
-  describe('TypeScript Analysis', () => {
-    it('should analyze TypeScript functions', () => {
-      const content = `
-export function addUser(name: string, email: string): User {
-  return database.createUser(name, email);
-}
-
-export async function getUserById(id: string): Promise<User | null> {
-  return database.findUser(id);
-}
-
-private function internalHelper() {
-  return 'secret';
-}
-      `;
-
-      const filePath = createTestFile('userService.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.language).toBe('typescript');
-      expect(analysis.exports).toContain('addUser');
-      expect(analysis.exports).toContain('getUserById');
-      expect(analysis.exports).not.toContain('internalHelper');
-      expect(analysis.functions).toHaveLength(3);
-    });
-
-    it('should analyze TypeScript classes', () => {
-      const content = `
-export class UserService {
-  private db: Database;
-
-  constructor(db: Database) {
-    this.db = db;
-  }
-
-  public async createUser(data: UserData): Promise<User> {
-    return this.db.insert(data);
-  }
-
-  public getUser(id: string): User {
-    return this.db.find(id);
-  }
-
-  private validate(data: UserData): boolean {
-    return !!data.email;
-  }
-}
-      `;
-
-      const filePath = createTestFile('userService.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.classes).toHaveLength(1);
-      expect(analysis.classes[0].name).toBe('UserService');
-      // The regex picks up methods with params (excluding constructor and properties)
-      expect(analysis.classes[0].methods.length).toBeGreaterThanOrEqual(2);
-      expect(analysis.classes[0].methods.some(m => m.name === 'createUser')).toBe(true);
-      expect(analysis.classes[0].methods.some(m => m.name === 'getUser')).toBe(true);
-    });
-
-    it('should analyze TypeScript imports', () => {
-      const content = `
-import { express, Request, Response } from 'express';
-import { Database } from './database';
-import axios from 'axios';
-import * as fs from 'fs';
-      `;
-
-      const filePath = createTestFile('app.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.imports.length).toBeGreaterThan(0);
-      expect(analysis.imports.some(i => i.module === 'express')).toBe(true);
-      expect(analysis.imports.some(i => i.module === './database')).toBe(true);
-      expect(analysis.imports.find(i => i.module === 'express')?.isExternal).toBe(true);
-      expect(analysis.imports.find(i => i.module === './database')?.isExternal).toBe(false);
-    });
-
-    it('should detect async functions', () => {
-      const content = `
-export async function fetchData(): Promise<Data> {
-  return await http.get('/data');
-}
-
-export function syncData(): Data {
-  return db.query('SELECT * FROM data');
-}
-      `;
-
-      const filePath = createTestFile('api.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      // The analyzer checks if 'async' appears before the function name
-      const asyncFn = analysis.functions.find(f => f.name === 'fetchData');
-      const syncFn = analysis.functions.find(f => f.name === 'syncData');
-      expect(asyncFn?.isAsync).toBe(true);
-      expect(syncFn?.isAsync).toBe(false);
-    });
-
-    it('should calculate function complexity', () => {
-      const content = `
-export function complexFunction(x: number): number {
-  if (x > 0) {
-    if (x > 10) {
-      for (let i = 0; i < x; i++) {
-        switch (i) {
-          case 1:
-            return x * 2;
-          case 2:
-            return x * 3;
-          default:
-            return x;
-        }
-      }
-    }
-  }
-  return x;
-}
-
-export function simpleFunction(x: number): number {
-  return x + 1;
-}
-      `;
-
-      const filePath = createTestFile('functions.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      const complexFn = analysis.functions.find(f => f.name === 'complexFunction');
-      const simpleFn = analysis.functions.find(f => f.name === 'simpleFunction');
-
-      expect(complexFn?.complexity).toBeGreaterThan(simpleFn?.complexity || 0);
-    });
-  });
-
-  describe('Python Analysis', () => {
-    it('should analyze Python functions', () => {
-      const content = `
-def create_user(name: str, email: str) -> User:
-    return db.create(name, email)
-
-async def get_user(id: str) -> User | None:
-    return await db.find(id)
-
-def _private_helper():
-    return "secret"
-      `;
-
-      const filePath = createTestFile('user_service.py', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.language).toBe('python');
-      // Python analysis has different behavior - only non-private functions are exports
-      expect(analysis.functions.length).toBeGreaterThan(0);
-      expect(analysis.exports).not.toContain('_private_helper');
-    });
-
-    it('should analyze Python classes', () => {
-      const content = `
-class UserService:
-    def __init__(self, db):
-        self.db = db
-
-    def create_user(self, data):
-        return self.db.insert(data)
-
-    def get_user(self, id):
-        return self.db.find(id)
-      `;
-
-      const filePath = createTestFile('user_service.py', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.classes).toHaveLength(1);
-      expect(analysis.classes[0].name).toBe('UserService');
-      // Note: Python class method extraction is basic - adds to functions, not class methods
-    });
-  });
-
-  describe('Go Analysis', () => {
-    it('should analyze Go functions', () => {
-      const content = `
-package main
-
-func CreateUser(name string, email string) User {
-    return db.Create(name, email)
-}
-
-func GetUserById(id string) User {
-    return db.Find(id)
-}
-
-func privateHelper() string {
-    return "secret"
-}
-      `;
-
-      const filePath = createTestFile('user_service.go', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.language).toBe('go');
-      expect(analysis.exports).toContain('CreateUser');
-      expect(analysis.exports).toContain('GetUserById');
-    });
-
-    it('should analyze Go structs', () => {
-      const content = `
-package main
-
-type User struct {
-    Name string
-    Email string
-}
-
-type ProductService struct {
-    db *Database
-}
-      `;
-
-      const filePath = createTestFile('models.go', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.classes).toHaveLength(2);
-      expect(analysis.classes[0].name).toBe('User');
-      expect(analysis.classes[1].name).toBe('ProductService');
-    });
-  });
-
-  describe('Directory Analysis', () => {
-    it('should analyze all source files in directory', () => {
-      mkdirSync(testDir, { recursive: true });
-
-      writeFileSync(join(testDir, 'file1.ts'), 'export function fn1() {}');
-      writeFileSync(join(testDir, 'file2.ts'), 'export function fn2() {}');
-      writeFileSync(join(testDir, 'README.md'), '# Readme');
-      writeFileSync(join(testDir, 'file3.js'), 'export function fn3() {}');
-
-      const results = analyzer.analyzeDirectory(testDir);
-
-      expect(results).toHaveLength(3);
-      expect(results.every(r => r.language === 'typescript' || r.language === 'javascript'));
-    });
-
-    it('should respect exclude patterns', () => {
-      mkdirSync(testDir, { recursive: true });
-      mkdirSync(join(testDir, 'node_modules'), { recursive: true });
-
-      writeFileSync(join(testDir, 'file.ts'), 'export function fn() {}');
-      writeFileSync(join(testDir, 'node_modules', 'dep.ts'), 'export function dep() {}');
-
-      const excludeAnalyzer = new SourceAnalyzer({ exclude: ['node_modules'] });
-      const results = excludeAnalyzer.analyzeDirectory(testDir);
-
-      expect(results).toHaveLength(1);
-      expect(results[0].filePath).not.toContain('node_modules');
-    });
-  });
-
-  describe('Test Specification Generation', () => {
-    it('should generate unit test spec from analysis', () => {
-      const content = `
-export function calculateDiscount(price: number, percentage: number): number {
-  return price * (1 - percentage / 100);
-}
-
-export function formatCurrency(amount: number): string {
-  return '$' + amount.toFixed(2);
-}
-      `;
-
-      const filePath = createTestFile('pricing.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const spec = analyzer.generateSpec(analysis);
-
-      expect(spec.type).toBe('unit');
-      expect(spec.source.language).toBe('typescript');
-      expect(spec.source.filePath).toBe(filePath);
-      expect(spec.source.exports).toHaveLength(2);
-      expect(spec.framework).toBe('vitest');
-    });
-
-    it('should recommend correct framework per language', () => {
-      const tsAnalyzer = new SourceAnalyzer();
-      const pyAnalyzer = new SourceAnalyzer();
-      const goAnalyzer = new SourceAnalyzer();
-
-      // Mock analyses
-      const tsAnalysis: SourceAnalysis = {
-        filePath: 'test.ts',
-        language: 'typescript',
-        exports: [],
-        functions: [],
-        classes: [],
-        imports: [],
-        hasTests: false,
-        complexity: 1,
-        linesOfCode: 10
-      };
-
-      const pyAnalysis: SourceAnalysis = { ...tsAnalysis, filePath: 'test.py', language: 'python' };
-      const goAnalysis: SourceAnalysis = { ...tsAnalysis, filePath: 'test.go', language: 'go' };
-
-      expect(tsAnalyzer.generateSpec(tsAnalysis).framework).toBe('vitest');
-      expect(pyAnalyzer.generateSpec(pyAnalysis).framework).toBe('pytest');
-      expect(goAnalyzer.generateSpec(goAnalysis).framework).toBe('go test');
-    });
-  });
-
-  describe('Test Suggestions', () => {
-    it('should generate unit test suggestions', () => {
-      const content = `
-export function validateEmail(email: string): boolean {
-  const regex = /^[^@]+@[^@]+\.[^@]+$/;
-  return regex.test(email);
-}
-
-export function sanitizeInput(input: string): string {
-  return input.trim().toLowerCase();
-}
-      `;
-
-      const filePath = createTestFile('validator.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const suggestions = analyzer.generateSuggestions(analysis);
-
-      expect(suggestions.length).toBeGreaterThan(0);
-
-      const unitSuggestions = suggestions.filter(s => s.type === 'unit');
-      expect(unitSuggestions.length).toBeGreaterThan(0);
-      expect(unitSuggestions[0].assertions).toBeDefined();
-      expect(unitSuggestions[0].assertions.length).toBeGreaterThan(0);
-    });
-
-    it('should suggest integration tests for complex classes', () => {
-      const content = `
-export class ComplexService {
-  constructor(dep1: Dep1, dep2: Dep2) {}
-
-  public method1() {}
-  public method2() {}
-  public method3() {}
-}
-      `;
-
-      const filePath = createTestFile('service.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const suggestions = analyzer.generateSuggestions(analysis);
-
-      const integrationSuggestions = suggestions.filter(s => s.type === 'integration');
-      expect(integrationSuggestions.length).toBeGreaterThan(0);
-    });
-
-    it('should suggest E2E tests for HTTP-using code', () => {
-      const content = `
-import axios from 'axios';
-
-export async function fetchUserData(id: string) {
-  const response = await axios.get(\`/api/users/\${id}\`);
-  return response.data;
-}
-      `;
-
-      const filePath = createTestFile('api.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const suggestions = analyzer.generateSuggestions(analysis);
-
-      const e2eSuggestions = suggestions.filter(s => s.type === 'e2e');
-      expect(e2eSuggestions.length).toBeGreaterThan(0);
-    });
-
-    it('should prioritize suggestions by complexity', () => {
-      const content = `
-export function simple() { return 1; }
-
-export function complex(x: number) {
-  if (x > 0) {
-    if (x > 10) {
-      for (let i = 0; i < x; i++) {
-        if (i % 2 === 0) {
-          return i * 2;
-        }
-      }
-    }
-  }
-  return x;
-}
-      `;
-
-      const filePath = createTestFile('functions.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const suggestions = analyzer.generateSuggestions(analysis);
-
-      // Complex function should have higher priority
-      const complexSuggestion = suggestions.find(s => s.functionName === 'complex');
-      expect(complexSuggestion).toBeDefined();
-      // Priority is determined by complexity score
-    });
-  });
-
-  describe('API Spec Generation', () => {
-    it('should generate API spec from Express handlers', () => {
-      const content = `
-export async function getUsers(req: Request, res: Response) {
-  const users = await db.findAll();
-  res.json(users);
-}
-
-export function createUser(req: Request, res: Response) {
-  const user = db.create(req.body);
-  res.status(201).json(user);
-}
-
-export function getUserById(req: Request, res: Response) {
-  const user = db.findById(req.params.id);
-  res.json(user);
-}
-      `;
-
-      const filePath = createTestFile('handlers.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const apiSpec = analyzer.generateApiSpec(analysis);
-
-      expect(apiSpec).not.toBeNull();
-      expect(apiSpec?.type).toBe('api');
-      expect(apiSpec?.endpoints).toHaveLength(3);
-    });
-
-    it('should detect HTTP methods from function names', () => {
-      const content = `
-export function getUser(req: Request, res: Response) {}
-export function postUser(req: Request, res: Response) {}
-export function deleteUser(req: Request, res: Response) {}
-      `;
-
-      const filePath = createTestFile('api.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const apiSpec = analyzer.generateApiSpec(analysis);
-
-      expect(apiSpec?.endpoints).toHaveLength(3);
-      expect(apiSpec?.endpoints[0].method).toBe('GET');
-      expect(apiSpec?.endpoints[1].method).toBe('POST');
-      expect(apiSpec?.endpoints[2].method).toBe('DELETE');
-    });
-  });
-
-  describe('Test File Detection', () => {
-    it('should detect existing test files', () => {
-      mkdirSync(testDir, { recursive: true });
-
-      const sourceFile = join(testDir, 'userService.ts');
-      const testFile = join(testDir, 'userService.test.ts');
-
-      writeFileSync(sourceFile, 'export function fn() {}');
-      writeFileSync(testFile, 'test content');
-
-      const analysis = analyzer.analyzeFile(sourceFile);
-
-      expect(analysis.hasTests).toBe(true);
-      expect(analysis.testFilePath).toBe(testFile);
-    });
-
-    it('should find test in __tests__ directory', () => {
-      mkdirSync(testDir, { recursive: true });
-      mkdirSync(join(testDir, '__tests__'), { recursive: true });
-
-      const sourceFile = join(testDir, 'userService.ts');
-      const testFile = join(testDir, '__tests__', 'userService.test.ts');
-
-      writeFileSync(sourceFile, 'export function fn() {}');
-      writeFileSync(testFile, 'test content');
-
-      const analysis = analyzer.analyzeFile(sourceFile);
-
-      expect(analysis.hasTests).toBe(true);
-      expect(analysis.testFilePath).toBeDefined();
-    });
-
-    it('should detect when no test file exists', () => {
-      const filePath = createTestFile('userService.ts', 'export function fn() {}');
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.hasTests).toBe(false);
-      expect(analysis.testFilePath).toBeUndefined();
-    });
-  });
-
-  describe('Lines of Code', () => {
-    it('should count lines of code correctly', () => {
-      const content = `
-line 1
-line 2
-line 3
-line 4
-line 5
-      `;
-
-      const filePath = createTestFile('test.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.linesOfCode).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Complexity Calculation', () => {
-    it('should calculate overall complexity', () => {
-      const content = `
-export function fn1() { return 1; }
-export function fn2() { if (true) return 2; }
-export function fn3() { if (a) { if (b) return 3; } }
-      `;
-
-      const filePath = createTestFile('test.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-
-      expect(analysis.complexity).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should throw error for non-existent file', () => {
-      expect(() => {
-        analyzer.analyzeFile('/non/existent/file.ts');
-      }).toThrow('Source file not found');
-    });
-
-    it('should throw error for non-existent directory', () => {
-      expect(() => {
-        analyzer.analyzeDirectory('/non/existent/dir');
-      }).toThrow('Directory not found');
-    });
-
-    it('should skip files that fail to analyze in directory mode', () => {
-      // This test verifies the graceful handling of parse errors
-      mkdirSync(testDir, { recursive: true });
-      writeFileSync(join(testDir, 'valid.ts'), 'export function fn() {}');
-
-      // Invalid file should be skipped, not throw
-      const results = analyzer.analyzeDirectory(testDir);
-      expect(results.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  describe('Convenience Functions', () => {
-    it('should analyze file using convenience function', () => {
-      const filePath = createTestFile('test.ts', 'export function fn() {}');
-      const analysis = analyzeSourceFile(filePath);
-
-      expect(analysis).toBeDefined();
-      expect(analysis.exports).toContain('fn');
-    });
-
-    it('should analyze directory using convenience function', () => {
-      mkdirSync(testDir, { recursive: true });
-      writeFileSync(join(testDir, 'file.ts'), 'export function fn() {}');
-
-      const results = analyzeSourceDirectory(testDir);
-      expect(results).toHaveLength(1);
-    });
-
-    it('should generate spec using convenience function', () => {
-      const filePath = createTestFile('test.ts', 'export function fn() {}');
-      const analysis = analyzer.analyzeFile(filePath);
-      const spec = generateTestSpec(analysis);
-
-      expect(spec.type).toBe('unit');
-    });
-  });
-
-  describe('Generation Source Conversion', () => {
-    it('should convert analysis to GenerationSource', () => {
-      const content = 'export function test() { return true; }';
-      const filePath = createTestFile('test.ts', content);
-      const analysis = analyzer.analyzeFile(filePath);
-      const source = analyzer.toGenerationSource(analysis);
-
-      expect(source.type).toBe('code');
-      expect(source.language).toBe('typescript');
-      expect(source.code).toContain('export function');
-    });
-  });
-
-  // Helper function to create test files
-  function createTestFile(name: string, content: string): string {
-    mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, name);
-    writeFileSync(filePath, content, 'utf-8');
-    return filePath;
-  }
-});
-
-describe('SourceAnalyzer Integration', () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    testDir = join(process.cwd(), '.tmp-test-source-integration');
-  });
-
-  afterEach(() => {
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('Full Workflow', () => {
-    it('should complete analyze → suggest → generate workflow', () => {
-      mkdirSync(testDir, { recursive: true });
-
-      const content = `
-/**
- * User service for managing users
- */
-import { Database } from './db';
-
-export class UserService {
-  constructor(private db: Database) {}
-
-  async createUser(name: string, email: string) {
-    return this.db.insert({ name, email });
-  }
-
-  async getUserById(id: string) {
-    return this.db.findById(id);
-  }
-
-  async updateUser(id: string, data: any) {
-    return this.db.update(id, data);
-  }
-
-  async deleteUser(id: string) {
-    return this.db.delete(id);
-  }
-}
-      `;
-
-      const filePath = join(testDir, 'userService.ts');
-      writeFileSync(filePath, content);
-
-      const analyzer = new SourceAnalyzer();
-      const analysis = analyzer.analyzeFile(filePath);
-      const suggestions = analyzer.generateSuggestions(analysis);
-      const spec = analyzer.generateSpec(analysis);
-
-      // Verify analysis
-      expect(analysis.classes).toHaveLength(1);
-      expect(analysis.classes[0].name).toBe('UserService');
-      expect(analysis.hasTests).toBe(false);
-
-      // Verify suggestions
-      expect(suggestions.length).toBeGreaterThan(0);
-      expect(suggestions.some(s => s.type === 'unit'));
-
-      // Verify spec
-      expect(spec.type).toBe('unit');
-      expect(spec.source.exports).toBeDefined();
-    });
-
-    it('should handle API handler analysis', () => {
-      mkdirSync(testDir, { recursive: true });
-
-      const content = `
-import { Router, Request, Response } from 'express';
-
-const router = Router();
-
-export async function getUsers(req: Request, res: Response): Promise<void> {
-  const users = await db.users.findAll();
-  res.json(users);
-}
-
-export async function getUser(req: Request, res: Response): Promise<void> {
-  const user = await db.users.findById(req.params.id);
-  res.json(user);
-}
-
-export async function createUser(req: Request, res: Response): Promise<void> {
-  const user = await db.users.create(req.body);
-  res.status(201).json(user);
-}
-
-export async function updateUser(req: Request, res: Response): Promise<void> {
-  const user = await db.users.update(req.params.id, req.body);
-  res.json(user);
-}
-
-export async function deleteUser(req: Request, res: Response): Promise<void> {
-  await db.users.delete(req.params.id);
-  res.status(204).send();
-}
-      `;
-
-      const filePath = join(testDir, 'handlers.ts');
-      writeFileSync(filePath, content);
-
-      const analyzer = new SourceAnalyzer();
-      const analysis = analyzer.analyzeFile(filePath);
-      const apiSpec = analyzer.generateApiSpec(analysis);
-
-      expect(apiSpec).not.toBeNull();
-      expect(apiSpec?.endpoints).toHaveLength(5);
-      // All handlers with req/res params default to GET unless name indicates otherwise
-      expect(apiSpec?.endpoints[0].method).toBe('GET');
-      expect(apiSpec?.endpoints).toBeDefined();
-    });
-  });
-
-  describe('Multi-File Project', () => {
-    it('should analyze entire project structure', () => {
-      mkdirSync(testDir, { recursive: true });
-      mkdirSync(join(testDir, 'src'), { recursive: true });
-      mkdirSync(join(testDir, 'src', 'services'), { recursive: true });
-
-      writeFileSync(join(testDir, 'src', 'index.ts'), 'export * from "./services";');
-      writeFileSync(join(testDir, 'src', 'services', 'user.ts'), 'export class UserService {}');
-      writeFileSync(join(testDir, 'src', 'services', 'auth.ts'), 'export class AuthService {}');
-      writeFileSync(join(testDir, 'src', 'services', 'data.ts'), 'export class DataService {}');
-
-      const analyzer = new SourceAnalyzer({ exclude: ['node_modules'] });
-      const results = analyzer.analyzeDirectory(join(testDir, 'src'));
-
-      expect(results).toHaveLength(4);
-      expect(results.some(r => r.classes.length > 0));
-    });
-  });
-});