auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/linter_core/tests/test_factory_manager.py

@@ -0,0 +1,234 @@
+"""
+Tests for linter factory and manager components.
+"""
+
+import pytest
+from unittest.mock import Mock, patch
+from pathlib import Path
+
+from autocoder.common.linter_core.linter_factory import LinterFactory
+from autocoder.common.linter_core.linter_manager import LinterManager
+from autocoder.common.linter_core.models.lint_result import LintResult
+from autocoder.common.linter_core.linters.python_linter import PythonLinter
+from autocoder.common.linter_core.linters.typescript_linter import TypeScriptLinter
+
+
+class TestLinterFactory:
+    """Test cases for LinterFactory."""
+    
+    def test_get_supported_languages(self):
+        """Test getting supported languages."""
+        languages = LinterFactory.get_supported_languages()
+        assert isinstance(languages, list)
+        assert 'python' in languages
+        assert 'typescript' in languages
+        assert 'java' in languages
+    
+    def test_get_supported_extensions(self):
+        """Test getting supported file extensions."""
+        extensions = LinterFactory.get_supported_extensions()
+        assert isinstance(extensions, list)
+        assert '.py' in extensions
+        assert '.ts' in extensions
+        assert '.tsx' in extensions
+        assert '.java' in extensions
+    
+    def test_create_linter_python(self):
+        """Test creating Python linter."""
+        linter = LinterFactory.create_linter('python')
+        assert isinstance(linter, PythonLinter)
+        assert linter.language_name == "Python"
+    
+    def test_create_linter_typescript(self):
+        """Test creating TypeScript linter."""
+        linter = LinterFactory.create_linter('typescript')
+        assert isinstance(linter, TypeScriptLinter)
+        assert linter.language_name == "TypeScript"
+    
+    def test_create_linter_with_config(self):
+        """Test creating linter with custom config."""
+        config = {'use_mypy': False}
+        linter = LinterFactory.create_linter('python', config)
+        assert isinstance(linter, PythonLinter)
+        assert linter.use_mypy is False
+    
+    def test_create_linter_unsupported(self):
+        """Test creating linter for unsupported language."""
+        linter = LinterFactory.create_linter('unsupported')
+        assert linter is None
+    
+    def test_create_linter_for_file_python(self):
+        """Test creating linter for Python file."""
+        linter = LinterFactory.create_linter_for_file('test.py')
+        assert isinstance(linter, PythonLinter)
+    
+    def test_create_linter_for_file_typescript(self):
+        """Test creating linter for TypeScript file."""
+        linter = LinterFactory.create_linter_for_file('test.ts')
+        assert isinstance(linter, TypeScriptLinter)
+    
+    def test_create_linter_for_file_java(self):
+        """Test creating linter for Java file."""
+        from autocoder.common.linter_core.linters.java_linter import JavaLinter
+        linter = LinterFactory.create_linter_for_file('Test.java')
+        assert isinstance(linter, JavaLinter)
+    
+    def test_create_linter_for_file_unsupported(self):
+        """Test creating linter for unsupported file."""
+        linter = LinterFactory.create_linter_for_file('test.txt')
+        assert linter is None
+    
+    def test_is_file_supported_true(self):
+        """Test checking if file is supported."""
+        assert LinterFactory.is_file_supported('test.py') is True
+        assert LinterFactory.is_file_supported('test.ts') is True
+        assert LinterFactory.is_file_supported('test.tsx') is True
+    
+    def test_is_file_supported_false(self):
+        """Test checking if file is not supported."""
+        assert LinterFactory.is_file_supported('test.txt') is False
+        assert LinterFactory.is_file_supported('test.md') is False
+
+
+class TestLinterManager:
+    """Test cases for LinterManager."""
+    
+    @pytest.fixture
+    def manager(self):
+        """Create a linter manager instance."""
+        return LinterManager()
+    
+    @pytest.fixture
+    def mock_linter(self):
+        """Create a mock linter."""
+        linter = Mock()
+        linter.name = "MockLinter"
+        linter.supported_extensions = ['.mock']
+        linter.is_available.return_value = True
+        return linter
+    
+    def test_manager_initialization(self, manager):
+        """Test manager initialization."""
+        assert isinstance(manager, LinterManager)
+        assert hasattr(manager, 'linters')
+        assert hasattr(manager, 'max_workers')
+        assert hasattr(manager, 'timeout')
+    
+    def test_manager_with_config(self):
+        """Test manager with custom config."""
+        config = {
+            'max_workers': 8,
+            'timeout': 600,
+            'python_config': {'use_mypy': False}
+        }
+        manager = LinterManager(config)
+        assert manager.max_workers == 8
+        assert manager.timeout == 600
+    
+    def test_get_available_linters(self, manager):
+        """Test getting available linters."""
+        available = manager.get_available_linters()
+        assert isinstance(available, dict)
+    
+    def test_add_custom_linter(self, manager, mock_linter):
+        """Test adding custom linter."""
+        manager.add_linter('mock', mock_linter)
+        assert 'mock' in manager.linters
+        assert manager.linters['mock'] == mock_linter
+    
+    def test_remove_linter(self, manager, mock_linter):
+        """Test removing linter."""
+        manager.add_linter('mock', mock_linter)
+        manager.remove_linter('mock')
+        assert 'mock' not in manager.linters
+    
+    def test_lint_file_not_found(self, manager):
+        """Test linting non-existent file."""
+        result = manager.lint_file('nonexistent.py')
+        assert isinstance(result, LintResult)
+        assert result.success is False
+        assert "File not found" in result.error_message
+    
+    @patch('pathlib.Path.exists')
+    def test_lint_file_no_linter(self, mock_exists, manager):
+        """Test linting file with no available linter."""
+        mock_exists.return_value = True
+        result = manager.lint_file('test.unsupported')
+        assert isinstance(result, LintResult)
+        assert result.success is False
+        assert "No available linter" in result.error_message
+    
+    def test_lint_files_empty(self, manager):
+        """Test linting empty file list."""
+        results = manager.lint_files([])
+        assert isinstance(results, dict)
+        assert len(results) == 0
+    
+    def test_get_summary_report_empty(self, manager):
+        """Test summary report for empty results."""
+        summary = manager.get_summary_report({})
+        assert summary['total_files'] == 0
+        assert summary['successful_files'] == 0
+        assert summary['failed_files'] == 0
+        assert summary['total_issues'] == 0
+    
+    def test_get_summary_report_with_results(self, manager):
+        """Test summary report with results."""
+        results = {
+            'file1.py': LintResult(
+                linter_name='TestLinter',
+                files_checked=['file1.py'],
+                success=True,
+                execution_time=1.0
+            ),
+            'file2.py': LintResult(
+                linter_name='TestLinter',
+                files_checked=['file2.py'],
+                success=False,
+                execution_time=0.5
+            )
+        }
+        
+        summary = manager.get_summary_report(results)
+        assert summary['total_files'] == 2
+        assert summary['successful_files'] == 1
+        assert summary['failed_files'] == 1
+        assert summary['total_execution_time'] == 1.0  # Only successful files counted
+    
+    def test_lint_output_filtering(self, manager):
+        """Test filtering based on lint output content."""
+        # Create test results with different lint outputs
+        result1 = LintResult(
+            linter_name='TestLinter',
+            files_checked=['test1.py'],
+            lint_output='test1.py:1:1: E301 expected 1 blank line, found 0'
+        )
+        result2 = LintResult(
+            linter_name='TestLinter',
+            files_checked=['test2.py'],
+            lint_output='test2.py:2:1: W291 trailing whitespace'
+        )
+        
+        results = {'test1.py': result1, 'test2.py': result2}
+        
+        # Test that results with lint output are correctly identified
+        files_with_issues = [
+            path for path, result in results.items() 
+            if result.has_issues
+        ]
+        
+        assert len(files_with_issues) == 2
+        assert 'test1.py' in files_with_issues
+        assert 'test2.py' in files_with_issues
+    
+    def test_format_results(self, manager):
+        """Test formatting results."""
+        result = LintResult(
+            linter_name='TestLinter',
+            files_checked=['test.py']
+        )
+        results = {'test.py': result}
+        
+        formatted = manager.format_results(results)
+        assert isinstance(formatted, dict)
+        assert 'test.py' in formatted

autocoder/common/linter_core/tests/test_formatters.py

@@ -0,0 +1,147 @@
+"""
+Tests for linter output formatters.
+"""
+
+import pytest
+from typing import Dict, Any
+
+from autocoder.common.linter_core.formatters.base_formatter import BaseLintOutputFormatter
+from autocoder.common.linter_core.formatters.raw_formatter import RawLintOutputFormatter
+from autocoder.common.linter_core.models.lint_result import LintResult
+
+
+class CustomTestFormatter(BaseLintOutputFormatter):
+    """Test implementation of formatter for testing abstract base class."""
+    
+    def format_result(self, result: LintResult) -> str:
+        """Format as a simple string."""
+        return f"{result.linter_name}: {result.file_name} - {result.lint_result}"
+    
+    def format_results(self, results: Dict[str, LintResult]) -> str:
+        """Override to return concatenated string."""
+        lines = []
+        for path, result in results.items():
+            lines.append(f"{path}: {self.format_result(result)}")
+        return "\n".join(lines)
+
+
+class TestBaseLintOutputFormatter:
+    """Test the base formatter abstract class."""
+    
+    def test_abstract_methods(self):
+        """Test that abstract methods must be implemented."""
+        with pytest.raises(TypeError):
+            # Cannot instantiate abstract class
+            BaseLintOutputFormatter()
+    
+    def test_custom_implementation(self):
+        """Test custom formatter implementation."""
+        formatter = CustomTestFormatter()
+        result = LintResult(
+            linter_name="TestLinter",
+            files_checked=["test.py"]
+        )
+        result.lint_result = "No issues found"
+        
+        formatted = formatter.format_result(result)
+        assert formatted == "TestLinter: test.py - No issues found"
+    
+    def test_format_results_default_behavior(self):
+        """Test default format_results implementation."""
+        formatter = CustomTestFormatter()
+        result1 = LintResult(
+            linter_name="Linter1",
+            files_checked=["file1.py"]
+        )
+        result1.lint_result = "Issue 1"
+        
+        result2 = LintResult(
+            linter_name="Linter2",
+            files_checked=["file2.py"]
+        )
+        result2.lint_result = "Issue 2"
+        
+        results = {
+            "file1.py": result1,
+            "file2.py": result2
+        }
+        
+        formatted = formatter.format_results(results)
+        assert "file1.py: Linter1: file1.py - Issue 1" in formatted
+        assert "file2.py: Linter2: file2.py - Issue 2" in formatted
+
+
+class TestRawLintOutputFormatter:
+    """Test the raw formatter implementation."""
+    
+    @pytest.fixture
+    def formatter(self):
+        """Create a raw formatter instance."""
+        return RawLintOutputFormatter()
+    
+    @pytest.fixture
+    def sample_result(self):
+        """Create a sample lint result."""
+        result = LintResult(
+            linter_name="PythonLinter",
+            files_checked=["example.py"],
+            metadata={"tool": "flake8", "severity": "error"}
+        )
+        result.lint_result = "line 10: undefined variable"
+        return result
+    
+    def test_format_result_returns_dict(self, formatter, sample_result):
+        """Test that format_result returns a dictionary."""
+        formatted = formatter.format_result(sample_result)
+        
+        assert isinstance(formatted, dict)
+        assert formatted["linter_name"] == "PythonLinter"
+        assert formatted["file_name"] == "example.py"
+        assert formatted["lint_result"] == "line 10: undefined variable"
+        assert formatted["metadata"]["tool"] == "flake8"
+    
+    def test_format_results_returns_dict_of_dicts(self, formatter):
+        """Test formatting multiple results."""
+        result1 = LintResult(
+            linter_name="Linter1",
+            files_checked=["file1.py"],
+            metadata={"line": 5}
+        )
+        result1.lint_result = "Issue 1"
+        
+        result2 = LintResult(
+            linter_name="Linter2",
+            files_checked=["file2.py"],
+            metadata={"line": 10}
+        )
+        result2.lint_result = "Issue 2"
+        
+        results = {
+            "file1.py": result1,
+            "file2.py": result2
+        }
+        
+        formatted = formatter.format_results(results)
+        
+        assert isinstance(formatted, dict)
+        assert len(formatted) == 2
+        assert "file1.py" in formatted
+        assert "file2.py" in formatted
+        assert formatted["file1.py"]["lint_result"] == "Issue 1"
+        assert formatted["file2.py"]["metadata"]["line"] == 10
+    
+    def test_empty_results(self, formatter):
+        """Test formatting empty results."""
+        formatted = formatter.format_results({})
+        assert formatted == {}
+    
+    def test_result_with_empty_metadata(self, formatter):
+        """Test result with no metadata."""
+        result = LintResult(
+            linter_name="TestLinter",
+            files_checked=["test.py"]
+        )
+        
+        formatted = formatter.format_result(result)
+        assert formatted["metadata"] == {}
+        assert formatted["lint_result"] == ""

autocoder/common/linter_core/tests/test_integration.py

@@ -0,0 +1,317 @@
+
+"""
+Integration tests for the linter core module.
+"""
+
+import pytest
+import tempfile
+import os
+from pathlib import Path
+from unittest.mock import patch, MagicMock, Mock
+
+from autocoder.common.linter_core import LinterManager, LinterFactory
+from autocoder.common.linter_core.models.lint_result import LintResult
+
+
+class TestIntegration:
+    """Integration tests with temporary project files."""
+    
+    @pytest.fixture
+    def temp_dir(self):
+        """Create a temporary directory for test files."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            yield Path(temp_dir)
+    
+    @pytest.fixture
+    def python_file(self, temp_dir):
+        """Create a temporary Python file."""
+        python_content = '''
+def hello_world():
+    print("Hello, World!")
+    return True
+
+if __name__ == "__main__":
+    hello_world()
+'''
+        python_file = temp_dir / "test.py"
+        python_file.write_text(python_content)
+        return python_file
+    
+    @pytest.fixture
+    def typescript_file(self, temp_dir):
+        """Create a temporary TypeScript file."""
+        ts_content = '''
+function greet(name: string): string {
+    return `Hello, ${name}!`;
+}
+
+export { greet };
+'''
+        ts_file = temp_dir / "test.ts"
+        ts_file.write_text(ts_content)
+        return ts_file
+    
+    @pytest.fixture
+    def mixed_project(self, temp_dir):
+        """Create a mixed project with multiple file types."""
+        # Python file
+        py_content = '''
+def calculate(x, y):
+    return x + y
+'''
+        (temp_dir / "calculator.py").write_text(py_content)
+        
+        # TypeScript file
+        ts_content = '''
+interface User {
+    name: string;
+    age: number;
+}
+
+function createUser(name: string, age: number): User {
+    return { name, age };
+}
+'''
+        (temp_dir / "user.ts").write_text(ts_content)
+        
+        # Java file
+        java_content = '''
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello, World!");
+    }
+}
+'''
+        (temp_dir / "HelloWorld.java").write_text(java_content)
+        
+        # Unsupported file
+        (temp_dir / "readme.txt").write_text("This is a readme file.")
+        
+        return temp_dir
+    
+    def test_factory_creates_appropriate_linters(self):
+        """Test that factory creates correct linters for different languages."""
+        python_linter = LinterFactory.create_linter('python')
+        typescript_linter = LinterFactory.create_linter('typescript')
+        java_linter = LinterFactory.create_linter('java')
+        
+        assert python_linter is not None
+        assert typescript_linter is not None
+        assert java_linter is not None
+        assert python_linter.language_name == "Python"
+        assert typescript_linter.language_name == "TypeScript"
+        assert java_linter.language_name == "Java"
+    
+    def test_factory_file_detection(self, python_file, typescript_file):
+        """Test that factory correctly detects file types."""
+        python_linter = LinterFactory.create_linter_for_file(python_file)
+        typescript_linter = LinterFactory.create_linter_for_file(typescript_file)
+        
+        assert python_linter is not None
+        assert typescript_linter is not None
+        assert python_linter.language_name == "Python"
+        assert typescript_linter.language_name == "TypeScript"
+    
+    @patch('subprocess.run')
+    def test_manager_lint_single_file(self, mock_run, python_file):
+        """Test manager linting a single file."""
+        # Mock flake8 output
+        mock_run.return_value = MagicMock(stdout="", stderr="", returncode=0)
+        
+        manager = LinterManager()
+        result = manager.lint_file(python_file)
+        
+        assert isinstance(result, LintResult)
+        assert result.linter_name == "PythonLinter"
+        assert str(python_file) in result.files_checked
+    
+    @patch('subprocess.run')
+    def test_manager_lint_directory(self, mock_run, mixed_project):
+        """Test manager linting an entire directory."""
+        # Mock subprocess calls
+        mock_run.return_value = MagicMock(stdout="", stderr="", returncode=0)
+        
+        manager = LinterManager()
+        results = manager.lint_directory(mixed_project)
+        
+        assert isinstance(results, dict)
+        # Should have results for .py, .ts, and .java files, but not .txt
+        assert len(results) >= 3
+        
+        # Check that we have results for supported files
+        py_files = [path for path in results.keys() if path.endswith('.py')]
+        ts_files = [path for path in results.keys() if path.endswith('.ts')]
+        java_files = [path for path in results.keys() if path.endswith('.java')]
+        
+        assert len(py_files) >= 1
+        assert len(ts_files) >= 1
+        assert len(java_files) >= 1
+    
+    @patch('subprocess.run')
+    def test_manager_parallel_processing(self, mock_run, mixed_project):
+        """Test manager with parallel processing."""
+        mock_run.return_value = MagicMock(stdout="", stderr="", returncode=0)
+        
+        manager = LinterManager({'max_workers': 2})
+        results = manager.lint_directory(mixed_project, parallel=True)
+        
+        assert isinstance(results, dict)
+        assert len(results) >= 2
+    
+    @patch('subprocess.run')
+    def test_manager_sequential_processing(self, mock_run, mixed_project):
+        """Test manager with sequential processing."""
+        mock_run.return_value = MagicMock(stdout="", stderr="", returncode=0)
+        
+        manager = LinterManager()
+        results = manager.lint_directory(mixed_project, parallel=False)
+        
+        assert isinstance(results, dict)
+        assert len(results) >= 2
+    
+    @patch('subprocess.run')
+    def test_manager_include_exclude_patterns(self, mock_run, mixed_project):
+        """Test manager with include/exclude patterns."""
+        mock_run.return_value = MagicMock(stdout="", stderr="", returncode=0)
+        
+        manager = LinterManager()
+        
+        # Test include pattern - only Python files
+        results = manager.lint_directory(
+            mixed_project, 
+            include_patterns=['*.py']
+        )
+        
+        py_files = [path for path in results.keys() if path.endswith('.py')]
+        ts_files = [path for path in results.keys() if path.endswith('.ts')]
+        
+        assert len(py_files) >= 1
+        assert len(ts_files) == 0
+    
+    def test_manager_summary_report(self):
+        """Test manager summary report generation."""
+        manager = LinterManager()
+        
+        # Create mock results
+        results = {
+            'file1.py': LintResult(
+                linter_name='PythonLinter',
+                files_checked=['file1.py'],
+                success=True,
+                execution_time=1.0
+            ),
+            'file2.ts': LintResult(
+                linter_name='TypeScriptLinter',
+                files_checked=['file2.ts'],
+                success=True,
+                execution_time=1.5
+            ),
+            'file3.py': LintResult(
+                linter_name='PythonLinter',
+                files_checked=['file3.py'],
+                success=False,
+                execution_time=0.0
+            )
+        }
+        
+        summary = manager.get_summary_report(results)
+        
+        assert summary['total_files'] == 3
+        assert summary['successful_files'] == 2
+        assert summary['failed_files'] == 1
+        assert summary['total_execution_time'] == 2.5
+        assert summary['average_execution_time'] == 1.25
+    
+    @patch('subprocess.run')
+    def test_end_to_end_workflow(self, mock_run, mixed_project):
+        """Test complete end-to-end workflow."""
+        # Mock subprocess calls with some lint output
+        mock_run.return_value = MagicMock(
+            stdout="test.py:1:1: E302 expected 2 blank lines",
+            stderr="",
+            returncode=1
+        )
+        
+        # Initialize manager
+        manager = LinterManager({
+            'max_workers': 2,
+            'timeout': 60,
+            'python_config': {'use_mypy': False}
+        })
+        
+        # Lint directory
+        results = manager.lint_directory(mixed_project, recursive=True)
+        
+        # Generate summary
+        summary = manager.get_summary_report(results)
+        
+        # Format results
+        formatted = manager.format_results(results)
+        
+        # Assertions
+        assert isinstance(results, dict)
+        assert isinstance(summary, dict)
+        assert isinstance(formatted, dict)
+        assert summary['total_files'] >= 2
+        assert len(formatted) == len(results)
+    
+    def test_linter_availability_check(self):
+        """Test checking linter availability."""
+        manager = LinterManager()
+        available = manager.get_available_linters()
+        
+        assert isinstance(available, dict)
+        # The dictionary should contain linter availability status
+        # Note: In test environment, linters may not be available
+        # but the structure should be correct
+        for language, is_available in available.items():
+            assert isinstance(is_available, bool)
+    
+    def test_error_handling_integration(self, python_file):
+        """Test error handling in integration scenario."""
+        # Create manager first, then patch the specific linter's lint_file method
+        manager = LinterManager()
+        
+        # Mock a linter to raise exception during linting
+        with patch.object(manager, '_get_linter_for_file') as mock_get_linter:
+            mock_linter = Mock()
+            mock_linter.lint_file.side_effect = Exception("Tool not found")
+            mock_get_linter.return_value = mock_linter
+            
+            result = manager.lint_file(python_file)
+            
+            assert isinstance(result, LintResult)
+            assert result.success is False
+            assert "Tool not found" in result.error_message
+    
+    def test_configuration_propagation(self):
+        """Test that configuration is properly propagated."""
+        config = {
+            'max_workers': 8,
+            'timeout': 120,
+            'python_config': {
+                'use_mypy': False,
+                'flake8_args': ['--max-line-length=120']
+            },
+            'typescript_config': {
+                'use_eslint': False,
+                'tsc_args': ['--strict']
+            }
+        }
+        
+        manager = LinterManager(config)
+        
+        assert manager.max_workers == 8
+        assert manager.timeout == 120
+        
+        # Check that linter configs are applied
+        if 'python' in manager.linters:
+            python_linter = manager.linters['python']
+            assert python_linter.use_mypy is False
+            assert '--max-line-length=120' in python_linter.flake8_args
+        
+        if 'typescript' in manager.linters:
+            ts_linter = manager.linters['typescript']
+            assert ts_linter.use_eslint is False
+            assert '--strict' in ts_linter.tsc_args
+