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

autocoder/common/linter_core/models.py

@@ -0,0 +1,33 @@
+"""
+Simple data models for lint results.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, List, Dict, Any
+
+
+@dataclass
+class LintResult:
+    """Simple result from linting a file."""
+    
+    file_path: str
+    success: bool
+    output: str = ""  # Raw output from the linter tool
+    error: Optional[str] = None  # Error message if linting failed
+    tool: str = ""  # Tool that generated this result (e.g., "flake8", "mypy")
+    
+    @property
+    def has_issues(self) -> bool:
+        """Check if there are any issues (non-empty output usually means issues)."""
+        return bool(self.output.strip())
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'file_path': self.file_path,
+            'success': self.success,
+            'output': self.output,
+            'error': self.error,
+            'tool': self.tool,
+            'has_issues': self.has_issues
+        }

autocoder/common/linter_core/tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for the linter core module.
+""" 

autocoder/common/linter_core/tests/test_config_loader.py

@@ -0,0 +1,323 @@
+"""
+Tests for the centralized configuration loader.
+"""
+
+import os
+import json
+import tempfile
+import pytest
+from unittest.mock import patch, Mock
+from pathlib import Path
+
+from autocoder.common.linter_core.config_loader import LinterConfigLoader, load_linter_config
+
+
+class TestLinterConfigLoader:
+    """Test cases for LinterConfigLoader."""
+    
+    @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 config_loader(self, temp_dir):
+        """Create a config loader instance."""
+        return LinterConfigLoader(source_dir=str(temp_dir))
+    
+    def test_default_config(self, config_loader):
+        """Test that default configuration is returned when no config files exist."""
+        config = config_loader.load_config()
+        
+        assert config == LinterConfigLoader.DEFAULT_CONFIG
+        assert config['enabled'] is False
+        assert config['mode'] == 'warning'
+        assert config['check_after_modification'] is True
+        assert config['report']['format'] == 'simple'
+        assert config['report']['include_in_result'] is True
+    
+    def test_load_from_explicit_path_json(self, config_loader, temp_dir):
+        """Test loading configuration from explicit JSON file path."""
+        config_data = {
+            'enabled': True,
+            'mode': 'blocking',
+            'report': {'format': 'detailed'}
+        }
+        
+        config_file = temp_dir / 'custom_config.json'
+        with open(config_file, 'w') as f:
+            json.dump(config_data, f)
+        
+        config = config_loader.load_config(config_path=str(config_file))
+        
+        assert config == config_data
+    
+    def test_load_from_explicit_path_yaml(self, config_loader, temp_dir):
+        """Test loading configuration from explicit YAML file path."""
+        config_data = {
+            'enabled': True,
+            'mode': 'silent',
+            'report': {'format': 'json'}
+        }
+        
+        config_file = temp_dir / 'custom_config.yaml'
+        
+        # Create YAML content manually (to avoid yaml dependency in test)
+        yaml_content = """
+enabled: true
+mode: silent
+report:
+  format: json
+"""
+        
+        with open(config_file, 'w') as f:
+            f.write(yaml_content)
+        
+        # Mock yaml.safe_load
+        with patch('yaml.safe_load') as mock_yaml:
+            mock_yaml.return_value = config_data
+            
+            config = config_loader.load_config(config_path=str(config_file))
+            
+            assert config == config_data
+    
+    def test_load_from_explicit_path_with_nested_key(self, config_loader, temp_dir):
+        """Test loading configuration with nested key extraction."""
+        full_config = {
+            'linter': {
+                'enabled': True,
+                'mode': 'warning'
+            },
+            'other_section': {
+                'key': 'value'
+            }
+        }
+        
+        config_file = temp_dir / 'nested_config.json'
+        with open(config_file, 'w') as f:
+            json.dump(full_config, f)
+        
+        config = config_loader.load_config(config_path=str(config_file), config_key='linter')
+        
+        assert config == full_config['linter']
+    
+    @patch.dict(os.environ, {'AUTOCODER_LINTER_CONFIG': '{"enabled": true, "mode": "blocking"}'})
+    def test_load_from_environment(self, config_loader):
+        """Test loading configuration from environment variable."""
+        config = config_loader.load_config()
+        
+        assert config['enabled'] is True
+        assert config['mode'] == 'blocking'
+    
+    @patch.dict(os.environ, {'AUTOCODER_LINTER_CONFIG': 'invalid json'})
+    def test_load_from_environment_invalid_json(self, config_loader):
+        """Test handling invalid JSON in environment variable."""
+        config = config_loader.load_config()
+        
+        # Should fall back to default config
+        assert config == LinterConfigLoader.DEFAULT_CONFIG
+    
+    def test_load_from_project_config_json(self, config_loader, temp_dir):
+        """Test loading configuration from project .autocoderlinters directory."""
+        config_data = {
+            'enabled': True,
+            'mode': 'warning',
+            'custom_field': 'project_value'
+        }
+        
+        # Create project config directory and file
+        project_config_dir = temp_dir / '.autocoderlinters'
+        project_config_dir.mkdir()
+        
+        config_file = project_config_dir / 'config.json'
+        with open(config_file, 'w') as f:
+            json.dump(config_data, f)
+        
+        config = config_loader.load_config()
+        
+        assert config == config_data
+    
+    def test_load_from_project_config_priority(self, config_loader, temp_dir):
+        """Test that config.json has priority over linter.yaml in project config."""
+        # Create project config directory
+        project_config_dir = temp_dir / '.autocoderlinters'
+        project_config_dir.mkdir()
+        
+        # Create both config.json and linter.yaml
+        json_config = {'enabled': True, 'source': 'json'}
+        yaml_config = {'enabled': False, 'source': 'yaml'}
+        
+        with open(project_config_dir / 'config.json', 'w') as f:
+            json.dump(json_config, f)
+        
+        with open(project_config_dir / 'linter.yaml', 'w') as f:
+            f.write('enabled: false\nsource: yaml\n')
+        
+        config = config_loader.load_config()
+        
+        # Should load JSON config (higher priority)
+        assert config == json_config
+        assert config['source'] == 'json'
+    
+    def test_load_from_global_config(self, config_loader, temp_dir):
+        """Test loading configuration from global user config directory."""
+        config_data = {
+            'enabled': True,
+            'mode': 'silent',
+            'global_setting': True
+        }
+        
+        # Mock the global config directory path to point to our temp dir
+        fake_global_dir = temp_dir / '.auto-coder' / '.autocoderlinters'
+        fake_global_dir.mkdir(parents=True)
+        
+        config_file = fake_global_dir / 'config.json'
+        with open(config_file, 'w') as f:
+            json.dump(config_data, f)
+        
+        # Mock os.path.expanduser to return our temp dir
+        with patch('os.path.expanduser', return_value=str(temp_dir)):
+            config = config_loader.load_config()
+        
+        assert config == config_data
+    
+    def test_config_priority_order(self, config_loader, temp_dir):
+        """Test configuration priority order: explicit > env > project > global > default."""
+        # Create project config
+        project_config_dir = temp_dir / '.autocoderlinters'
+        project_config_dir.mkdir()
+        
+        project_config = {'enabled': False, 'source': 'project'}
+        with open(project_config_dir / 'config.json', 'w') as f:
+            json.dump(project_config, f)
+        
+        # Create explicit config file
+        explicit_config = {'enabled': True, 'source': 'explicit'}
+        explicit_file = temp_dir / 'explicit.json'
+        with open(explicit_file, 'w') as f:
+            json.dump(explicit_config, f)
+        
+        # Test explicit config has highest priority
+        config = config_loader.load_config(config_path=str(explicit_file))
+        assert config['source'] == 'explicit'
+        
+        # Test project config is used when no explicit config
+        config = config_loader.load_config()
+        assert config['source'] == 'project'
+    
+    def test_validate_config(self, config_loader):
+        """Test configuration validation and normalization."""
+        # Test with valid config
+        valid_config = {
+            'enabled': True,
+            'mode': 'blocking',
+            'report': {
+                'format': 'detailed',
+                'include_in_result': False
+            }
+        }
+        
+        validated = config_loader.validate_config(valid_config)
+        
+        assert validated['enabled'] is True
+        assert validated['mode'] == 'blocking'
+        assert validated['report']['format'] == 'detailed'
+        assert validated['report']['include_in_result'] is False
+        # Should still have default values for missing keys
+        assert 'check_after_modification' in validated
+    
+    def test_validate_config_invalid_mode(self, config_loader):
+        """Test validation with invalid mode value."""
+        invalid_config = {
+            'enabled': True,
+            'mode': 'invalid_mode'  # Invalid mode
+        }
+        
+        validated = config_loader.validate_config(invalid_config)
+        
+        assert validated['mode'] == 'warning'  # Should fallback to default
+    
+    def test_validate_config_invalid_report_format(self, config_loader):
+        """Test validation with invalid report format."""
+        invalid_config = {
+            'enabled': True,
+            'report': {
+                'format': 'invalid_format'  # Invalid format
+            }
+        }
+        
+        validated = config_loader.validate_config(invalid_config)
+        
+        assert validated['report']['format'] == 'simple'  # Should fallback to default
+    
+    def test_validate_config_non_dict(self, config_loader):
+        """Test validation with non-dictionary input."""
+        validated = config_loader.validate_config("not a dict")
+        
+        assert validated == LinterConfigLoader.DEFAULT_CONFIG
+    
+    def test_load_manager_config(self, temp_dir):
+        """Test loading full configuration for LinterManager."""
+        full_config = {
+            'max_workers': 8,
+            'timeout': 600,
+            'linter': {
+                'enabled': True,
+                'mode': 'warning'
+            },
+            'python_config': {
+                'use_mypy': True
+            }
+        }
+        
+        # Create project config
+        project_config_dir = temp_dir / '.autocoderlinters'
+        project_config_dir.mkdir()
+        
+        with open(project_config_dir / 'config.json', 'w') as f:
+            json.dump(full_config, f)
+        
+        config = LinterConfigLoader.load_manager_config(source_dir=str(temp_dir))
+        
+        assert config == full_config
+        assert config['max_workers'] == 8
+        assert config['linter']['enabled'] is True
+        assert config['python_config']['use_mypy'] is True
+    
+    def test_load_manager_config_empty(self):
+        """Test loading manager config when no config files exist."""
+        config = LinterConfigLoader.load_manager_config(source_dir='/nonexistent')
+        
+        assert config == {}
+
+
+class TestConvenienceFunction:
+    """Test the convenience function."""
+    
+    def test_load_linter_config_function(self):
+        """Test the load_linter_config convenience function."""
+        config = load_linter_config()
+        
+        # Should return default config when no files exist
+        assert isinstance(config, dict)
+        assert 'enabled' in config
+        assert 'mode' in config
+        assert 'report' in config
+    
+    def test_load_linter_config_with_params(self):
+        """Test convenience function with parameters."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            config_data = {'enabled': True, 'mode': 'blocking'}
+            config_file = Path(temp_dir) / 'test_config.json'
+            
+            with open(config_file, 'w') as f:
+                json.dump(config_data, f)
+            
+            config = load_linter_config(
+                config_path=str(config_file),
+                source_dir=temp_dir
+            )
+            
+            assert config['enabled'] is True
+            assert config['mode'] == 'blocking'

autocoder/common/linter_core/tests/test_config_loading.py

@@ -0,0 +1,308 @@
+
+"""
+测试 LinterManager 的配置文件自动加载功能
+"""
+
+import os
+import json
+import yaml
+import tempfile
+import pytest
+from unittest.mock import patch, Mock
+from pathlib import Path
+
+from autocoder.common.linter_core.linter_manager import LinterManager
+from autocoder.common.priority_directory_finder import SearchResult
+
+
+class TestConfigLoading:
+    """测试配置文件加载功能"""
+    
+    def test_init_with_explicit_config(self):
+        """测试：使用显式配置初始化"""
+        config = {
+            'max_workers': 8,
+            'timeout': 600,
+            'python_config': {'use_mypy': True}
+        }
+        
+        manager = LinterManager(config)
+        
+        assert manager.global_config == config
+        assert manager.max_workers == 8
+        assert manager.timeout == 600
+    
+    def test_init_without_config_no_files_found(self):
+        """测试：没有配置文件时的初始化"""
+        # Mock QuickFinder 返回未找到配置文件
+        mock_result = SearchResult(
+            strategy=None,
+            success=False,
+            selected_directories=[],
+            all_valid_directories=[]
+        )
+        
+        with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+            manager = LinterManager()
+            
+            assert manager.global_config == {}
+            assert manager.max_workers == 4  # 默认值
+            assert manager.timeout == 300     # 默认值
+    
+    def test_load_json_config_file(self):
+        """测试：加载 JSON 配置文件"""
+        config_data = {
+            'max_workers': 6,
+            'timeout': 500,
+            'python_config': {
+                'use_mypy': True,
+                'flake8_args': ['--max-line-length=120']
+            }
+        }
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 创建配置文件
+            config_file = os.path.join(temp_dir, 'config.json')
+            with open(config_file, 'w') as f:
+                json.dump(config_data, f)
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                manager = LinterManager()
+                
+                assert manager.global_config == config_data
+                assert manager.max_workers == 6
+                assert manager.timeout == 500
+    
+    def test_load_yaml_config_file(self):
+        """测试：加载 YAML 配置文件"""
+        config_data = {
+            'max_workers': 12,
+            'timeout': 800,
+            'typescript_config': {
+                'use_eslint': True,
+                'tsc_args': ['--strict']
+            }
+        }
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 创建配置文件
+            config_file = os.path.join(temp_dir, 'config.yaml')
+            with open(config_file, 'w') as f:
+                yaml.dump(config_data, f)
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                manager = LinterManager()
+                
+                assert manager.global_config == config_data
+                assert manager.max_workers == 12
+                assert manager.timeout == 800
+    
+    def test_config_file_priority_order(self):
+        """测试：配置文件优先级顺序"""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 创建多个配置文件，config.json 应该优先
+            config_json = {'max_workers': 10, 'source': 'json'}
+            config_yaml = {'max_workers': 20, 'source': 'yaml'}
+            
+            with open(os.path.join(temp_dir, 'config.json'), 'w') as f:
+                json.dump(config_json, f)
+            
+            with open(os.path.join(temp_dir, 'linter.yaml'), 'w') as f:
+                yaml.dump(config_yaml, f)
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                manager = LinterManager()
+                
+                # 应该加载 config.json（优先级更高）
+                assert manager.global_config == config_json
+                assert manager.global_config['source'] == 'json'
+    
+    def test_config_file_fallback_order(self):
+        """测试：配置文件回退顺序"""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 只创建 linter.yml 文件
+            config_data = {'max_workers': 15, 'source': 'yml'}
+            
+            with open(os.path.join(temp_dir, 'linter.yml'), 'w') as f:
+                yaml.dump(config_data, f)
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                manager = LinterManager()
+                
+                # 应该加载 linter.yml（唯一可用的配置文件）
+                assert manager.global_config == config_data
+                assert manager.global_config['source'] == 'yml'
+    
+    def test_invalid_config_file_handling(self):
+        """测试：处理无效的配置文件"""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 创建无效的 JSON 文件
+            invalid_json = os.path.join(temp_dir, 'config.json')
+            with open(invalid_json, 'w') as f:
+                f.write('{ invalid json content }')
+            
+            # 创建有效的 YAML 文件作为备选
+            valid_yaml = os.path.join(temp_dir, 'config.yaml')
+            config_data = {'max_workers': 8, 'source': 'yaml_backup'}
+            with open(valid_yaml, 'w') as f:
+                yaml.dump(config_data, f)
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                # 应该捕获 JSON 解析错误，然后加载 YAML 文件
+                manager = LinterManager()
+                
+                assert manager.global_config == config_data
+                assert manager.global_config['source'] == 'yaml_backup'
+    
+    def test_priority_directory_finder_integration(self):
+        """测试：与 priority_directory_finder 的集成"""
+        # 这个测试验证 QuickFinder.find_standard_directories 被正确调用
+        with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories') as mock_finder:
+            mock_result = SearchResult(
+                strategy=None,
+                success=False,
+                selected_directories=[],
+                all_valid_directories=[]
+            )
+            mock_finder.return_value = mock_result
+            
+            manager = LinterManager()
+            
+            # 验证 QuickFinder 被正确调用
+            mock_finder.assert_called_once()
+            call_args = mock_finder.call_args
+            
+            assert call_args[1]['base_name'] == '.autocoderlinters'
+            assert call_args[1]['current_dir'] is None
+            assert call_args[1]['file_extensions'] == ['json', 'yaml', 'yml']
+    
+    def test_load_config_file_unsupported_format(self):
+        """测试：加载不支持的配置文件格式"""
+        manager = LinterManager({})  # 创建一个实例来测试 _load_config_file 方法
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            unsupported_file = os.path.join(temp_dir, 'config.txt')
+            with open(unsupported_file, 'w') as f:
+                f.write('some content')
+            
+            with pytest.raises(ValueError, match="Unsupported configuration file format"):
+                manager._load_config_file(unsupported_file)
+    
+    def test_empty_yaml_config_file(self):
+        """测试：空的 YAML 配置文件"""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 创建空的 YAML 文件
+            config_file = os.path.join(temp_dir, 'config.yaml')
+            with open(config_file, 'w') as f:
+                f.write('')  # 空文件
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                manager = LinterManager()
+                
+                # 空的 YAML 文件应该返回空字典
+                assert manager.global_config == {}
+    
+    def test_config_file_with_complex_structure(self):
+        """测试：复杂结构的配置文件"""
+        complex_config = {
+            'max_workers': 16,
+            'timeout': 1200,
+            'python_config': {
+                'use_mypy': True,
+                'flake8_args': ['--max-line-length=120', '--ignore=E501'],
+                'mypy_args': ['--strict', '--no-implicit-optional'],
+                'flake8_timeout': 60,
+                'mypy_timeout': 90
+            },
+            'typescript_config': {
+                'use_eslint': True,
+                'tsc_args': ['--noEmit', '--strict'],
+                'eslint_args': ['--ext', '.ts,.tsx'],
+                'tsconfig_path': './tsconfig.json'
+            },
+            'java_config': {
+                'javac_args': ['-Xlint:all', '-Werror'],
+                'javac_timeout': 45
+            }
+        }
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            config_file = os.path.join(temp_dir, 'config.json')
+            with open(config_file, 'w') as f:
+                json.dump(complex_config, f, indent=2)
+            
+            # Mock QuickFinder 返回找到的目录
+            mock_result = SearchResult(
+                strategy=None,
+                success=True,
+                selected_directories=[temp_dir],
+                all_valid_directories=[temp_dir]
+            )
+            
+            with patch('autocoder.common.linter_core.linter_manager.QuickFinder.find_standard_directories', return_value=mock_result):
+                manager = LinterManager()
+                
+                assert manager.global_config == complex_config
+                assert manager.max_workers == 16
+                assert manager.timeout == 1200
+                
+                # 验证嵌套配置被正确加载
+                python_config = manager.global_config.get('python_config', {})
+                assert python_config.get('use_mypy') is True
+                assert python_config.get('flake8_timeout') == 60
+                
+                typescript_config = manager.global_config.get('typescript_config', {})
+                assert typescript_config.get('use_eslint') is True
+                assert typescript_config.get('tsconfig_path') == './tsconfig.json'
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])