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

autocoder/common/linter_core/tests/test_linters.py

@@ -0,0 +1,265 @@
+"""
+Tests for specific linter implementations.
+"""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+import subprocess
+from pathlib import Path
+
+from autocoder.common.linter_core.linters.python_linter import PythonLinter
+from autocoder.common.linter_core.linters.typescript_linter import TypeScriptLinter
+from autocoder.common.linter_core.models.lint_result import LintResult
+
+
+class TestPythonLinter:
+    """Test cases for PythonLinter."""
+    
+    @pytest.fixture
+    def python_linter(self):
+        """Create a PythonLinter instance."""
+        return PythonLinter()
+    
+    def test_init_default_config(self):
+        """Test PythonLinter initialization with default config."""
+        linter = PythonLinter()
+        assert linter.use_mypy is True
+        assert linter.flake8_args == []
+        assert linter.mypy_args == []
+        assert linter.flake8_timeout_secs == 30
+        assert linter.mypy_timeout_secs == 30
+    
+    def test_init_custom_config(self):
+        """Test PythonLinter initialization with custom config."""
+        config = {
+            'use_mypy': False,
+            'flake8_args': ['--max-line-length=120'],
+            'mypy_args': ['--strict'],
+            'flake8_timeout': 60,
+            'mypy_timeout': 45
+        }
+        linter = PythonLinter(config)
+        assert linter.use_mypy is False
+        assert linter.flake8_args == ['--max-line-length=120']
+        assert linter.mypy_args == ['--strict']
+        assert linter.flake8_timeout_secs == 60
+        assert linter.mypy_timeout_secs == 45
+    
+    def test_supported_extensions(self, python_linter):
+        """Test supported file extensions."""
+        assert python_linter.supported_extensions == ['.py', '.pyx', '.pyi']
+    
+    def test_language_name(self, python_linter):
+        """Test language name property."""
+        assert python_linter.language_name == "Python"
+    
+    @patch('subprocess.run')
+    def test_is_available_true(self, mock_run, python_linter):
+        """Test is_available when flake8 is installed."""
+        mock_run.return_value = MagicMock(returncode=0)
+        assert python_linter.is_available() is True
+        mock_run.assert_called_once_with(
+            ['flake8', '--version'], 
+            capture_output=True, 
+            check=True, 
+            timeout=10
+        )
+    
+    @patch('subprocess.run')
+    def test_is_available_false(self, mock_run, python_linter):
+        """Test is_available when flake8 is not installed."""
+        mock_run.side_effect = FileNotFoundError()
+        assert python_linter.is_available() is False
+    
+    @patch('subprocess.run')
+    def test_lint_file_flake8_only(self, mock_run):
+        """Test linting a file with only flake8."""
+        # Setup
+        linter = PythonLinter({'use_mypy': False})
+        mock_run.return_value = MagicMock(
+            stdout="test.py:1:1: E302 expected 2 blank lines, found 1",
+            stderr=""
+        )
+        
+        # Execute
+        result = linter.lint_file('test.py')
+        
+        # Verify
+        assert result.linter_name == "PythonLinter"
+        assert result.file_name == "test.py"
+        assert "=== flake8 ===" in result.lint_result
+        assert "E302 expected 2 blank lines" in result.lint_result
+        assert result.metadata['mypy_enabled'] is False
+        assert result.metadata['tools_used'] == ['flake8']
+    
+    @patch('subprocess.run')
+    def test_lint_file_with_mypy(self, mock_run):
+        """Test linting a file with both flake8 and mypy."""
+        # Setup
+        linter = PythonLinter({'use_mypy': True})
+        
+        # Mock flake8 and mypy calls
+        mock_run.side_effect = [
+            # flake8 call
+            MagicMock(stdout="test.py:1:1: E302 expected 2 blank lines", stderr=""),
+            # mypy availability check
+            MagicMock(returncode=0),
+            # mypy call
+            MagicMock(stdout="test.py:5: error: Name 'foo' is not defined", stderr="")
+        ]
+        
+        # Execute
+        result = linter.lint_file('test.py')
+        
+        # Verify
+        assert "=== flake8 ===" in result.lint_result
+        assert "=== mypy ===" in result.lint_result
+        assert "E302 expected 2 blank lines" in result.lint_result
+        assert "Name 'foo' is not defined" in result.lint_result
+        assert result.metadata['mypy_enabled'] is True
+        assert result.metadata['tools_used'] == ['flake8', 'mypy']
+    
+    @patch('subprocess.run')
+    def test_lint_file_timeout(self, mock_run):
+        """Test handling of timeout during linting."""
+        linter = PythonLinter()
+        mock_run.side_effect = subprocess.TimeoutExpired(['flake8'], 30)
+        
+        result = linter.lint_file('test.py')
+        assert "Error: flake8 execution timed out" in result.lint_result
+        assert result.metadata.get('error') is True
+
+
+class TestTypeScriptLinter:
+    """Test cases for TypeScriptLinter."""
+    
+    @pytest.fixture
+    def ts_linter(self):
+        """Create a TypeScriptLinter instance."""
+        return TypeScriptLinter()
+    
+    def test_init_default_config(self):
+        """Test TypeScriptLinter initialization with default config."""
+        linter = TypeScriptLinter()
+        assert linter.use_eslint is True
+        assert linter.tsc_args == ['--noEmit', '--strict']
+        assert linter.eslint_args == []
+        assert linter.tsconfig_path is None
+        assert linter.tsc_timeout_secs == 60
+        assert linter.eslint_timeout_secs == 30
+    
+    def test_init_custom_config(self):
+        """Test TypeScriptLinter initialization with custom config."""
+        config = {
+            'use_eslint': False,
+            'tsc_args': ['--noEmit'],
+            'eslint_args': ['--fix'],
+            'tsconfig_path': './tsconfig.json',
+            'tsc_timeout': 90,
+            'eslint_timeout': 45
+        }
+        linter = TypeScriptLinter(config)
+        assert linter.use_eslint is False
+        assert linter.tsc_args == ['--noEmit']
+        assert linter.eslint_args == ['--fix']
+        assert linter.tsconfig_path == './tsconfig.json'
+        assert linter.tsc_timeout_secs == 90
+        assert linter.eslint_timeout_secs == 45
+    
+    def test_supported_extensions(self, ts_linter):
+        """Test supported file extensions."""
+        assert ts_linter.supported_extensions == ['.ts', '.tsx', '.js', '.jsx']
+    
+    def test_language_name(self, ts_linter):
+        """Test language name property."""
+        assert ts_linter.language_name == "TypeScript"
+    
+    @patch('subprocess.run')
+    def test_is_available_true(self, mock_run, ts_linter):
+        """Test is_available when tsc is installed."""
+        mock_run.return_value = MagicMock(returncode=0)
+        assert ts_linter.is_available() is True
+        mock_run.assert_called_once_with(
+            ['tsc', '--version'], 
+            capture_output=True, 
+            check=True, 
+            timeout=10
+        )
+    
+    @patch('subprocess.run')
+    def test_is_available_false(self, mock_run, ts_linter):
+        """Test is_available when tsc is not installed."""
+        mock_run.side_effect = FileNotFoundError()
+        assert ts_linter.is_available() is False
+    
+    @patch('subprocess.run')
+    @patch('time.time')
+    def test_lint_file_tsc_only(self, mock_time, mock_run):
+        """Test linting a file with only tsc."""
+        # Setup
+        mock_time.side_effect = [0, 1]  # Start and end time
+        linter = TypeScriptLinter({'use_eslint': False})
+        mock_run.return_value = MagicMock(
+            stdout="",
+            stderr="test.ts(1,5): error TS2322: Type 'string' is not assignable to type 'number'."
+        )
+        
+        # Execute
+        result = linter.lint_file('test.ts')
+        
+        # Verify
+        assert result.linter_name == "TypeScriptLinter"
+        assert len(result.files_checked) == 1
+        assert 'test.ts' in result.files_checked[0]
+        assert result.has_issues
+        assert "=== tsc ===" in result.lint_output
+        assert "Type 'string' is not assignable" in result.lint_output
+        assert result.metadata['eslint_enabled'] is False
+        assert result.metadata['tools_used'] == ['tsc']
+        assert result.execution_time == 1
+    
+    @patch('subprocess.run')
+    @patch('time.time')
+    def test_lint_file_with_eslint(self, mock_time, mock_run):
+        """Test linting a file with both tsc and eslint."""
+        # Setup
+        mock_time.side_effect = [0, 2]  # Start and end time
+        linter = TypeScriptLinter({'use_eslint': True})
+        
+        # Mock tsc and eslint calls
+        mock_run.side_effect = [
+            # tsc call
+            MagicMock(stdout="", stderr="test.ts(1,5): error TS2322: Type error"),
+            # eslint availability check
+            MagicMock(returncode=0),
+            # eslint call
+            MagicMock(stdout="test.ts:2:10 warning Missing semicolon", stderr="")
+        ]
+        
+        # Execute
+        result = linter.lint_file('test.ts')
+        
+        # Verify
+        assert result.has_issues
+        assert "=== tsc ===" in result.lint_output
+        assert "=== eslint ===" in result.lint_output
+        assert "Type error" in result.lint_output
+        assert "Missing semicolon" in result.lint_output
+        assert result.metadata['eslint_enabled'] is True
+        assert result.metadata['tools_used'] == ['tsc', 'eslint']
+    
+    @patch('subprocess.run')
+    def test_lint_file_with_tsconfig(self, mock_run):
+        """Test linting with custom tsconfig path."""
+        linter = TypeScriptLinter({
+            'tsconfig_path': './custom-tsconfig.json',
+            'use_eslint': False  # Disable eslint to test only tsc
+        })
+        mock_run.return_value = MagicMock(stdout="", stderr="")
+        
+        linter.lint_file('test.ts')
+        
+        # Verify tsc was called with --project argument
+        call_args = mock_run.call_args[0][0]
+        assert '--project' in call_args
+        assert './custom-tsconfig.json' in call_args

autocoder/common/linter_core/tests/test_models.py

@@ -0,0 +1,81 @@
+"""
+Tests for lint result models.
+"""
+
+import pytest
+from autocoder.common.linter_core.models.lint_result import LintResult
+
+
+class TestLintResult:
+    """Test cases for LintResult model."""
+    
+    def test_lint_result_creation(self):
+        """Test creating a LintResult instance."""
+        result = LintResult(
+            linter_name="TestLinter",
+            files_checked=["test.py"],
+            metadata={"key": "value"}
+        )
+        # Set lint_result using property for backward compatibility
+        result.lint_result = "Some lint output"
+        
+        assert result.linter_name == "TestLinter"
+        assert result.file_name == "test.py"
+        assert result.lint_result == "Some lint output"
+        assert result.metadata == {"key": "value"}
+    
+    def test_lint_result_defaults(self):
+        """Test LintResult with default values."""
+        result = LintResult(
+            linter_name="TestLinter",
+            files_checked=["test.py"]
+        )
+        
+        assert result.lint_result == ""
+        assert result.metadata == {}
+    
+    def test_to_dict(self):
+        """Test converting LintResult to dictionary."""
+        result = LintResult(
+            linter_name="TestLinter",
+            files_checked=["test.py"],
+            metadata={"tool": "flake8"}
+        )
+        result.lint_result = "Lint output"
+        
+        data = result.to_dict()
+        expected_keys = {
+            'linter_name', 'files_checked', 'lint_output', 'execution_time',
+            'success', 'error_message', 'metadata', 'file_name', 'lint_result'
+        }
+        assert set(data.keys()) == expected_keys
+        assert data['linter_name'] == 'TestLinter'
+        assert data['file_name'] == 'test.py'
+        assert data['lint_result'] == 'Lint output'
+        assert data['metadata'] == {'tool': 'flake8'}
+    
+    def test_from_dict(self):
+        """Test creating LintResult from dictionary."""
+        data = {
+            'linter_name': 'TestLinter',
+            'file_name': 'test.py',
+            'lint_result': 'Lint output',
+            'metadata': {'tool': 'mypy'}
+        }
+        
+        result = LintResult.from_dict(data)
+        assert result.linter_name == "TestLinter"
+        assert result.file_name == "test.py"
+        assert result.lint_result == "Lint output"
+        assert result.metadata == {"tool": "mypy"}
+    
+    def test_from_dict_missing_fields(self):
+        """Test creating LintResult from incomplete dictionary."""
+        data = {
+            'linter_name': 'TestLinter',
+            'file_name': 'test.py'
+        }
+        
+        result = LintResult.from_dict(data)
+        assert result.lint_result == ""
+        assert result.metadata == {}

autocoder/common/linter_core/tests/verify_config_loading.py

@@ -0,0 +1,296 @@
+
+
+"""
+验证 LinterManager 配置文件自动加载功能的脚本
+
+这个脚本演示了如何使用新的配置文件自动加载功能，
+并测试不同的配置文件位置和格式。
+"""
+
+import os
+import json
+import yaml
+import tempfile
+import shutil
+from pathlib import Path
+
+from autocoder.common.linter_core.linter_manager import LinterManager
+
+
+def create_test_config_directories():
+    """创建测试配置目录结构"""
+    print("=== 创建测试配置目录结构 ===")
+    
+    # 创建临时目录作为项目根目录
+    project_root = tempfile.mkdtemp(prefix="linter_test_")
+    print(f"项目根目录: {project_root}")
+    
+    # 创建不同优先级的配置目录
+    config_dirs = {
+        "project_level": os.path.join(project_root, ".autocoderlinters"),
+        "project_auto_coder": os.path.join(project_root, ".auto-coder", ".autocoderlinters"),
+        "global_level": os.path.expanduser("~/.auto-coder/.autocoderlinters")
+    }
+    
+    for name, path in config_dirs.items():
+        os.makedirs(path, exist_ok=True)
+        print(f"创建目录: {name} -> {path}")
+    
+    return project_root, config_dirs
+
+
+def create_sample_configs(config_dirs):
+    """创建示例配置文件"""
+    print("\n=== 创建示例配置文件 ===")
+    
+    # 项目级配置（最高优先级）
+    project_config = {
+        "max_workers": 8,
+        "timeout": 600,
+        "python_config": {
+            "use_mypy": True,
+            "flake8_args": ["--max-line-length=120"]
+        },
+        "source": "project_level"
+    }
+    
+    project_config_file = os.path.join(config_dirs["project_level"], "config.json")
+    with open(project_config_file, 'w') as f:
+        json.dump(project_config, f, indent=2)
+    print(f"创建项目级配置: {project_config_file}")
+    
+    # .auto-coder 级配置（中等优先级）
+    auto_coder_config = {
+        "max_workers": 6,
+        "timeout": 500,
+        "typescript_config": {
+            "use_eslint": True,
+            "tsc_args": ["--strict"]
+        },
+        "source": "auto_coder_level"
+    }
+    
+    auto_coder_config_file = os.path.join(config_dirs["project_auto_coder"], "config.yaml")
+    with open(auto_coder_config_file, 'w') as f:
+        yaml.dump(auto_coder_config, f)
+    print(f"创建 .auto-coder 级配置: {auto_coder_config_file}")
+    
+    # 全局配置（最低优先级）
+    global_config = {
+        "max_workers": 4,
+        "timeout": 300,
+        "java_config": {
+            "javac_args": ["-Xlint:all"]
+        },
+        "source": "global_level"
+    }
+    
+    global_config_file = os.path.join(config_dirs["global_level"], "config.yaml")
+    with open(global_config_file, 'w') as f:
+        yaml.dump(global_config, f)
+    print(f"创建全局配置: {global_config_file}")
+    
+    return {
+        "project": project_config,
+        "auto_coder": auto_coder_config,
+        "global": global_config
+    }
+
+
+def test_config_loading_priority(project_root, config_dirs, sample_configs):
+    """测试配置加载优先级"""
+    print("\n=== 测试配置加载优先级 ===")
+    
+    # 保存当前工作目录
+    original_cwd = os.getcwd()
+    
+    try:
+        # 切换到项目目录
+        os.chdir(project_root)
+        
+        # 测试1: 所有配置文件都存在，应该加载项目级配置
+        print("\n1. 测试所有配置文件都存在的情况:")
+        manager = LinterManager()
+        print(f"   加载的配置源: {manager.global_config.get('source', 'unknown')}")
+        print(f"   max_workers: {manager.max_workers}")
+        print(f"   timeout: {manager.timeout}")
+        assert manager.global_config['source'] == 'project_level', "应该加载项目级配置"
+        
+        # 测试2: 删除项目级配置，应该加载 .auto-coder 级配置
+        print("\n2. 测试删除项目级配置后:")
+        os.remove(os.path.join(config_dirs["project_level"], "config.json"))
+        manager = LinterManager()
+        print(f"   加载的配置源: {manager.global_config.get('source', 'unknown')}")
+        print(f"   max_workers: {manager.max_workers}")
+        print(f"   timeout: {manager.timeout}")
+        assert manager.global_config['source'] == 'auto_coder_level', "应该加载 .auto-coder 级配置"
+        
+        # 测试3: 删除 .auto-coder 级配置，应该加载全局配置
+        print("\n3. 测试删除 .auto-coder 级配置后:")
+        os.remove(os.path.join(config_dirs["project_auto_coder"], "config.yaml"))
+        manager = LinterManager()
+        print(f"   加载的配置源: {manager.global_config.get('source', 'unknown')}")
+        print(f"   max_workers: {manager.max_workers}")
+        print(f"   timeout: {manager.timeout}")
+        assert manager.global_config['source'] == 'global_level', "应该加载全局配置"
+        
+        # 测试4: 删除所有配置文件，应该使用默认配置
+        print("\n4. 测试删除所有配置文件后:")
+        os.remove(os.path.join(config_dirs["global_level"], "config.yaml"))
+        manager = LinterManager()
+        print(f"   配置为空: {manager.global_config == {}}")
+        print(f"   max_workers (默认): {manager.max_workers}")
+        print(f"   timeout (默认): {manager.timeout}")
+        assert manager.global_config == {}, "应该使用空配置"
+        assert manager.max_workers == 4, "应该使用默认 max_workers"
+        assert manager.timeout == 300, "应该使用默认 timeout"
+        
+    finally:
+        # 恢复原始工作目录
+        os.chdir(original_cwd)
+
+
+def test_different_config_formats(project_root):
+    """测试不同的配置文件格式"""
+    print("\n=== 测试不同的配置文件格式 ===")
+    
+    original_cwd = os.getcwd()
+    
+    try:
+        os.chdir(project_root)
+        
+        # 创建配置目录
+        config_dir = os.path.join(project_root, ".autocoderlinters")
+        os.makedirs(config_dir, exist_ok=True)
+        
+        # 测试 JSON 格式
+        print("\n1. 测试 JSON 格式:")
+        json_config = {
+            "max_workers": 10,
+            "format": "json",
+            "python_config": {"use_mypy": True}
+        }
+        
+        json_file = os.path.join(config_dir, "config.json")
+        with open(json_file, 'w') as f:
+            json.dump(json_config, f)
+        
+        manager = LinterManager()
+        print(f"   格式: {manager.global_config.get('format')}")
+        print(f"   max_workers: {manager.max_workers}")
+        assert manager.global_config['format'] == 'json'
+        
+        # 清理并测试 YAML 格式
+        os.remove(json_file)
+        
+        print("\n2. 测试 YAML 格式:")
+        yaml_config = {
+            "max_workers": 12,
+            "format": "yaml",
+            "typescript_config": {"use_eslint": True}
+        }
+        
+        yaml_file = os.path.join(config_dir, "config.yaml")
+        with open(yaml_file, 'w') as f:
+            yaml.dump(yaml_config, f)
+        
+        manager = LinterManager()
+        print(f"   格式: {manager.global_config.get('format')}")
+        print(f"   max_workers: {manager.max_workers}")
+        assert manager.global_config['format'] == 'yaml'
+        
+        # 清理并测试 YML 格式
+        os.remove(yaml_file)
+        
+        print("\n3. 测试 YML 格式:")
+        yml_config = {
+            "max_workers": 14,
+            "format": "yml",
+            "java_config": {"javac_args": ["-Xlint:all"]}
+        }
+        
+        yml_file = os.path.join(config_dir, "config.yml")
+        with open(yml_file, 'w') as f:
+            yaml.dump(yml_config, f)
+        
+        manager = LinterManager()
+        print(f"   格式: {manager.global_config.get('format')}")
+        print(f"   max_workers: {manager.max_workers}")
+        assert manager.global_config['format'] == 'yml'
+        
+    finally:
+        os.chdir(original_cwd)
+
+
+def test_explicit_config_override():
+    """测试显式配置覆盖自动加载"""
+    print("\n=== 测试显式配置覆盖自动加载 ===")
+    
+    explicit_config = {
+        "max_workers": 20,
+        "timeout": 1000,
+        "source": "explicit"
+    }
+    
+    manager = LinterManager(explicit_config)
+    print(f"配置源: {manager.global_config.get('source')}")
+    print(f"max_workers: {manager.max_workers}")
+    print(f"timeout: {manager.timeout}")
+    
+    assert manager.global_config['source'] == 'explicit'
+    assert manager.max_workers == 20
+    assert manager.timeout == 1000
+
+
+def cleanup_test_directories(project_root, config_dirs):
+    """清理测试目录"""
+    print("\n=== 清理测试目录 ===")
+    
+    # 删除项目根目录
+    if os.path.exists(project_root):
+        shutil.rmtree(project_root)
+        print(f"删除项目目录: {project_root}")
+    
+    # 删除全局配置目录（如果是我们创建的）
+    global_dir = config_dirs["global_level"]
+    if os.path.exists(global_dir):
+        try:
+            shutil.rmtree(global_dir)
+            print(f"删除全局配置目录: {global_dir}")
+        except OSError:
+            print(f"无法删除全局配置目录: {global_dir} (可能有其他文件)")
+
+
+def main():
+    """主函数"""
+    print("开始验证 LinterManager 配置文件自动加载功能")
+    print("=" * 60)
+    
+    try:
+        # 创建测试环境
+        project_root, config_dirs = create_test_config_directories()
+        sample_configs = create_sample_configs(config_dirs)
+        
+        # 运行测试
+        test_config_loading_priority(project_root, config_dirs, sample_configs)
+        test_different_config_formats(project_root)
+        test_explicit_config_override()
+        
+        print("\n" + "=" * 60)
+        print("✅ 所有测试通过！配置文件自动加载功能工作正常。")
+        
+    except Exception as e:
+        print(f"\n❌ 测试失败: {e}")
+        raise
+    
+    finally:
+        # 清理测试环境
+        if 'project_root' in locals() and 'config_dirs' in locals():
+            cleanup_test_directories(project_root, config_dirs)
+    
+    print("\n验证完成！")
+
+
+if __name__ == '__main__':
+    main()
+