coverage-tool 1.0.0__py3-none-any.whl

coverage_tool/runners/go_runner.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Go单测运行器
+"""
+
+import subprocess
+import os
+import shutil
+from typing import List, Tuple, Optional
+
+from coverage_tool.converters import JUnitReportConverter
+from .base import BaseRunner, RunResult, CoverageExtractor
+
+
+class GoRunner(BaseRunner):
+    """Go单测运行器"""
+    
+    def _ensure_go_junit_report(self) -> bool:
+        """确保 go-junit-report 工具已安装，未安装时自动安装"""
+        # 检查是否已安装
+        result = subprocess.run(
+            ["which", "go-junit-report"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            self.logger.debug("go-junit-report 已安装")
+            return True
+        
+        # 未安装，尝试自动安装
+        self.logger.info("[工具安装] go-junit-report 未安装，正在自动安装...")
+        install_result = subprocess.run(
+            ["go", "install", "github.com/jstemmer/go-junit-report/v2@latest"],
+            capture_output=True,
+            text=True,
+            timeout=120
+        )
+        
+        if install_result.returncode == 0:
+            # 获取 GOPATH 并添加到 PATH
+            go_path_result = subprocess.run(
+                ["go", "env", "GOPATH"],
+                capture_output=True,
+                text=True
+            )
+            if go_path_result.returncode == 0:
+                go_path = go_path_result.stdout.strip()
+                gopath_bin = os.path.join(go_path, "bin")
+                current_path = os.environ.get('PATH', '')
+                if gopath_bin not in current_path:
+                    os.environ['PATH'] = f"{gopath_bin}:{current_path}"
+            
+            self.logger.info("[工具安装] ✓ go-junit-report 安装成功")
+            return True
+        else:
+            self.logger.warning(f"[工具安装] ✗ go-junit-report 安装失败: {install_result.stderr}")
+            return False
+    
+    def run_tests(self, target_dir: str, output_file: str) -> RunResult:
+        """运行Go测试"""
+        # 确保 go-junit-report 已安装（Go依赖由go test自动下载）
+        has_junit_tool = self._ensure_go_junit_report()
+        
+        # 运行测试（标准输出格式，不是-json）
+        cmd = "go test -v -cover -coverprofile=coverage.out ./... 2>&1"
+        result = self._run_command(cmd, target_dir)
+        
+        # 使用 go-junit-report 生成 JUnit XML
+        if result.stdout:
+            junit_xml_generated = False
+            
+            if has_junit_tool:
+                try:
+                    # 使用 go-junit-report 转换
+                    report_cmd = ["go-junit-report", "-set-exit-code"]
+                    junit_result = subprocess.run(
+                        report_cmd,
+                        input=result.stdout,
+                        capture_output=True,
+                        text=True,
+                        timeout=60
+                    )
+                    
+                    if junit_result.returncode == 0 or junit_result.stdout:
+                        with open(output_file, 'w') as f:
+                            f.write(junit_result.stdout)
+                        result.junit_xml_path = output_file
+                        junit_xml_generated = True
+                        self.logger.info("[报告生成] ✓ 使用 go-junit-report 生成 JUnit XML")
+                    else:
+                        self.logger.warning(f"[报告生成] go-junit-report 执行失败: {junit_result.stderr}")
+                except Exception as e:
+                    self.logger.warning(f"[报告生成] go-junit-report 执行错误: {e}")
+            
+            # 如果 go-junit-report 失败或未安装，使用内置转换作为备用
+            if not junit_xml_generated:
+                try:
+                    xml_content = JUnitReportConverter.convert_go_test(result.stdout)
+                    with open(output_file, 'w') as f:
+                        f.write(xml_content)
+                    result.junit_xml_path = output_file
+                    self.logger.info("[报告生成] ✓ 使用内置转换器生成 JUnit XML")
+                except Exception as e:
+                    self.logger.error(f"转换Go测试输出失败: {e}")
+        
+        # 复制coverage.out到临时目录
+        project_coverage = os.path.join(target_dir, "coverage.out")
+        if os.path.exists(project_coverage):
+            temp_dir = os.path.dirname(output_file)
+            if temp_dir:
+                temp_coverage = os.path.join(temp_dir, "coverage.out")
+                shutil.copy2(project_coverage, temp_coverage)
+        
+        result.coverage_rate = self.get_coverage(output_file, target_dir)
+        
+        return result
+    
+    def get_coverage(self, output_file: str, target_dir: Optional[str] = None) -> float:
+        """获取Go覆盖率"""
+        # 尝试多个可能的 coverage.out 位置
+        possible_paths = []
+        
+        # 1. 临时目录
+        if output_file:
+            temp_dir = os.path.dirname(output_file)
+            if temp_dir:
+                possible_paths.append(os.path.join(temp_dir, "coverage.out"))
+        
+        # 2. 目标项目目录（最重要）
+        if target_dir:
+            possible_paths.append(os.path.join(target_dir, "coverage.out"))
+        
+        # 3. 当前工作目录
+        possible_paths.append(os.path.join(os.getcwd(), "coverage.out"))
+        
+        # 尝试每个路径
+        for coverage_path in possible_paths:
+            if os.path.exists(coverage_path):
+                self.logger.debug(f"找到Go覆盖率文件: {coverage_path}")
+                coverage = CoverageExtractor.extract_from_coverage_out(coverage_path, 'go')
+                if coverage > 0:
+                    return coverage
+        
+        self.logger.warning("未找到Go覆盖率文件 (coverage.out)")
+        return 0.0
+    
+    def compile(self, target_dir: str) -> Tuple[bool, List[str]]:
+        """编译Go项目"""
+        cmd = "go build ./"
+        result = self._run_command(cmd, target_dir)
+        
+        errors = []
+        if not result.success:
+            for line in result.stderr.split('\n'):
+                if line.strip() and ('#' in line or 'error' in line.lower()):
+                    errors.append(line.strip())
+        
+        return result.success, errors

coverage_tool/runners/java_runner.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+Java单测运行器
+"""
+
+import os
+from typing import List, Tuple
+
+from .base import BaseRunner, RunResult, CoverageExtractor
+
+
+class JavaRunner(BaseRunner):
+    """Java单测运行器"""
+    
+    def run_tests(self, target_dir: str, output_file: str) -> RunResult:
+        """运行Java测试"""
+        # 使用Maven运行测试
+        cmd = f"mvn test -Dtest.output={output_file}"
+        result = self._run_command(cmd, target_dir)
+        
+        # Maven通常生成surefire报告
+        surefire_report = os.path.join(target_dir, "target", "surefire-reports")
+        if os.path.exists(surefire_report):
+            # 转换surefire报告为JUnit XML
+            self._convert_surefire_reports(surefire_report, output_file)
+        
+        result.junit_xml_path = output_file if os.path.exists(output_file) else None
+        result.coverage_rate = self.get_coverage(output_file)
+        
+        return result
+    
+    def _convert_surefire_reports(self, surefire_dir: str, output_file: str):
+        """转换Surefire报告为JUnit XML"""
+        # 这里简化处理，实际应该解析XML并合并
+        pass
+    
+    def get_coverage(self, output_file: str) -> float:
+        """获取Java覆盖率（JaCoCo）"""
+        # JaCoCo报告通常在 target/site/jacoco/index.html
+        jacoco_html = os.path.join("target", "site", "jacoco", "index.html")
+        return CoverageExtractor.extract_from_jacoco(jacoco_html)
+    
+    def compile(self, target_dir: str) -> Tuple[bool, List[str]]:
+        """编译Java项目"""
+        cmd = "mvn compile"
+        result = self._run_command(cmd, target_dir)
+        
+        errors = []
+        if not result.success:
+            for line in result.stderr.split('\n'):
+                if 'error:' in line.lower() or 'cannot find symbol' in line.lower():
+                    errors.append(line.strip())
+        
+        return result.success, errors

coverage_tool/runners/python_runner.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Python单测运行器
+"""
+
+import subprocess
+import os
+import shutil
+from typing import List, Tuple
+
+from .base import BaseRunner, RunResult
+
+
+class PythonRunner(BaseRunner):
+    """Python单测运行器"""
+    
+    def run_tests(self, target_dir: str, output_file: str) -> RunResult:
+        """运行Python测试"""
+        output_dir = os.path.dirname(output_file) if output_file else target_dir
+        
+        # 使用 coverage 运行测试，同时生成 JUnit XML
+        cmd = f"python3 -m coverage run --source={target_dir} -m pytest --junitxml={output_file} -v {target_dir}"
+        result = self._run_command(cmd, target_dir)
+        result.junit_xml_path = output_file if os.path.exists(output_file) else None
+        
+        # 复制 .coverage 文件到输出目录（如果需要）
+        project_coverage = os.path.join(target_dir, ".coverage")
+        if os.path.exists(project_coverage) and output_dir != target_dir:
+            temp_coverage = os.path.join(output_dir, ".coverage")
+            try:
+                shutil.copy2(project_coverage, temp_coverage)
+            except Exception as e:
+                self.logger.debug(f"复制覆盖率文件失败: {e}")
+        
+        # 计算覆盖率
+        result.coverage_rate = self.get_coverage(output_file)
+        
+        return result
+    
+    def get_coverage(self, output_file: str) -> float:
+        """获取Python覆盖率"""
+        output_dir = os.path.dirname(output_file) if output_file else "."
+        
+        try:
+            # 检查是否存在 .coverage 数据文件
+            coverage_file = os.path.join(output_dir, ".coverage")
+            
+            if not os.path.exists(coverage_file):
+                # 如果没有覆盖率数据，尝试运行测试收集
+                self.logger.debug("未找到覆盖率数据，尝试收集...")
+                return 0.0
+            
+            # 生成覆盖率报告
+            cmd = "python3 -m coverage report --omit='*test*'"
+            result = subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                cwd=output_dir
+            )
+            
+            if result.returncode == 0:
+                for line in result.stdout.split('\n'):
+                    if 'TOTAL' in line:
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            try:
+                                coverage = float(parts[-1].replace('%', ''))
+                                self.logger.info(f"从覆盖率报告读取: {coverage:.2f}%")
+                                return coverage
+                            except:
+                                pass
+            else:
+                self.logger.warning(f"生成覆盖率报告失败: {result.stderr}")
+        except Exception as e:
+            self.logger.error(f"获取Python覆盖率失败: {e}")
+        
+        return 0.0
+    
+    def compile(self, target_dir: str) -> Tuple[bool, List[str]]:
+        """Python语法检查"""
+        errors = []
+        py_files = self.find_files(target_dir, "*.py")
+        
+        for py_file in py_files:
+            try:
+                result = subprocess.run(
+                    f"python3 -m py_compile {py_file}",
+                    shell=True,
+                    capture_output=True,
+                    text=True
+                )
+                if result.returncode != 0:
+                    errors.append(f"语法错误: {py_file} - {result.stderr}")
+            except Exception as e:
+                errors.append(f"检查失败: {py_file} - {str(e)}")
+        
+        return len(errors) == 0, errors

coverage_tool/test_removers/__init__.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+测试删除器包
+
+重构后的模块化测试删除器，支持多种编程语言。
+
+Usage:
+    from test_removers import SmartTestRemoverFactory
+
+    remover = SmartTestRemoverFactory.get_remover('python', '/path/to/project')
+    test_functions = remover.find_test_functions('/path/to/test_file.py')
+"""
+
+from .base import (
+    BaseSmartTestRemover,
+    TestFunction,
+    TestRemovalStrategy,
+)
+
+from .python_remover import PythonSmartTestRemover
+from .java_remover import JavaSmartTestRemover
+from .go_remover import GoSmartTestRemover
+from .c_remover import CSmartTestRemover
+from .cpp_remover import CPPSmartTestRemover
+
+from .factory import SmartTestRemoverFactory
+
+__all__ = [
+    'BaseSmartTestRemover',
+    'TestFunction',
+    'TestRemovalStrategy',
+    'PythonSmartTestRemover',
+    'JavaSmartTestRemover',
+    'GoSmartTestRemover',
+    'CSmartTestRemover',
+    'CPPSmartTestRemover',
+    'SmartTestRemoverFactory',
+]

coverage_tool/test_removers/base.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+测试删除器基础模块
+包含公共数据结构和基类
+"""
+
+import os
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+
+from coverage_tool.utils import FileBackupManager, Logger
+from coverage_tool.parsers import TestStatus, TestReport, TestCase
+
+
+@dataclass
+class TestFunction:
+    """测试函数信息"""
+    name: str
+    file_path: str
+    start_line: int
+    end_line: int
+    decorators: List[str] = field(default_factory=list)
+    is_class_method: bool = False
+    class_name: Optional[str] = None
+
+
+class TestRemovalStrategy(Enum):
+    """测试删除策略"""
+    DELETE_FUNCTION = 1      # 仅删除测试函数
+    DELETE_FILE = 2          # 删除整个测试文件
+    COMMENT_OUT = 3          # 注释掉测试（保留代码）
+
+
+class BaseSmartTestRemover(ABC):
+    """智能测试删除器基类"""
+    
+    def __init__(self, project_dir: str, logger: Optional[Logger] = None):
+        self.project_dir = project_dir
+        self.logger = logger or Logger()
+        self.backup_manager = FileBackupManager()
+        self.deleted_tests: List[TestFunction] = []
+        self.removal_strategy = TestRemovalStrategy.DELETE_FUNCTION
+    
+    @abstractmethod
+    def find_test_functions(self, file_path: str) -> List[TestFunction]:
+        """查找文件中的所有测试函数"""
+        pass
+    
+    @abstractmethod
+    def find_test_file(self, test_case: TestCase) -> Optional[str]:
+        """根据测试用例找到对应的测试文件"""
+        pass
+    
+    def _get_deletion_range(self, test_func: TestFunction, lines: List[str]) -> tuple:
+        """
+        获取要删除的行范围
+        子类可以覆盖此方法以调整删除范围（例如考虑装饰器/注解）
+        
+        Returns:
+            (start_idx, end_idx) - 行索引（0-based）
+        """
+        start_idx = test_func.start_line - 1
+        end_idx = test_func.end_line
+        return start_idx, end_idx
+    
+    def _adjust_start_for_decorators(self, test_func: TestFunction, lines: List[str], 
+                                     comment_prefixes: Optional[List[str]] = None) -> int:
+        """
+        向上查找装饰器/注解，调整删除起始行
+        
+        Args:
+            test_func: 测试函数信息
+            lines: 文件行列表
+            comment_prefixes: 注释前缀列表（如 ['#', '//']）
+        
+        Returns:
+            调整后的起始行索引（0-based）
+        """
+        start_idx = test_func.start_line - 1
+        
+        while start_idx > 0:
+            line = lines[start_idx - 1].strip()
+            # 检查是否是装饰器/注解行
+            if line.startswith('@'):
+                start_idx -= 1
+            # 检查是否是空行或注释行
+            elif line == '':
+                start_idx -= 1
+            elif comment_prefixes:
+                is_comment = any(line.startswith(prefix) for prefix in comment_prefixes)
+                if is_comment:
+                    start_idx -= 1
+                else:
+                    break
+            else:
+                break
+        
+        return start_idx
+    
+    def remove_test_function(self, test_func: TestFunction) -> bool:
+        """
+        删除单个测试函数 - 通用实现
+        
+        这是通用的文件行删除逻辑，适用于大多数语言。
+        对于需要特殊处理的场景，子类可以覆盖 _get_deletion_range 方法。
+        """
+        try:
+            with open(test_func.file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            
+            # 获取删除范围（可以由子类调整）
+            start_idx, end_idx = self._get_deletion_range(test_func, lines)
+            
+            # 删除指定行范围
+            new_lines = lines[:start_idx] + lines[end_idx:]
+            
+            # 写回文件
+            with open(test_func.file_path, 'w', encoding='utf-8') as f:
+                f.writelines(new_lines)
+            
+            return True
+        
+        except Exception as e:
+            self.logger.error(f"删除测试函数失败 {test_func.file_path}:{test_func.name}: {e}")
+            return False
+    
+    def remove_failed_tests(self, test_report: TestReport) -> tuple:
+        """
+        删除所有失败的测试
+        
+        Returns:
+            (删除数量, 删除的测试列表)
+        """
+        total_deleted = 0
+        deleted_list = []
+        
+        for suite in test_report.suites:
+            for test_case in suite.test_cases:
+                if test_case.status in [TestStatus.FAILED, TestStatus.ERROR]:
+                    file_path = self.find_test_file(test_case)
+                    
+                    if not file_path or not os.path.exists(file_path):
+                        self.logger.warning(f"找不到测试文件: {test_case.classname}.{test_case.name}")
+                        continue
+                    
+                    # 处理特殊的构建失败
+                    if self._is_build_failure(test_case.name):
+                        self.logger.info(f"[编译错误] 包 {test_case.classname} 构建失败，准备删除该包的所有测试文件")
+                        pkg_deleted_count, pkg_deleted_files = self.remove_all_tests_in_package(test_case.classname)
+                        if pkg_deleted_count > 0:
+                            total_deleted += pkg_deleted_count
+                            for f in pkg_deleted_files:
+                                deleted_list.append(f"{f}:BUILD_FAILURE_DELETED")
+                            self.logger.info(f"[编译错误] ✓ 已删除 {pkg_deleted_count} 个测试文件解决包级编译错误")
+                        else:
+                            self.logger.warning(f"[编译错误] 未能找到包 {test_case.classname} 的测试文件")
+                        continue
+                    
+                    # 查找测试函数
+                    test_funcs = self.find_test_functions(file_path)
+                    target_func = None
+                    
+                    for func in test_funcs:
+                        if func.name == test_case.name or self._match_test_name(func.name, test_case.name):
+                            target_func = func
+                            break
+                    
+                    if target_func:
+                        # 备份文件
+                        self.backup_manager.backup_file(file_path)
+                        
+                        # 删除测试函数
+                        if self.remove_test_function(target_func):
+                            total_deleted += 1
+                            deleted_list.append(f"{file_path}:{target_func.name}")
+                            self.deleted_tests.append(target_func)
+                            self.logger.info(f"已删除测试函数: {file_path}:{target_func.name}")
+                        else:
+                            self.logger.error(f"删除测试函数失败: {file_path}:{target_func.name}")
+                    else:
+                        self.logger.warning(f"在文件 {file_path} 中找不到测试函数: {test_case.name}")
+        
+        return total_deleted, deleted_list
+    
+    def _is_build_failure(self, test_name: str) -> bool:
+        """检查是否是构建失败的特殊测试名称"""
+        build_failure_patterns = [
+            '[build failed]',
+            '[no test files]',
+            '[setup failed]',
+        ]
+        return any(pattern in test_name for pattern in build_failure_patterns)
+    
+    def remove_all_tests_in_package(self, package_path: str) -> tuple:
+        """
+        删除指定包内的所有测试文件
+        用于处理包级编译错误
+        
+        Returns:
+            (删除数量, 删除的文件列表)
+        """
+        # 基类提供默认实现，子类应覆盖以提供语言特定的逻辑
+        return 0, []
+    
+    def _match_test_name(self, func_name: str, test_name: str) -> bool:
+        """匹配测试名称（处理不同的命名方式）"""
+        # 完全匹配
+        if func_name == test_name:
+            return True
+        
+        # 忽略大小写匹配
+        if func_name.lower() == test_name.lower():
+            return True
+        
+        # 处理 Go 的测试名称（TestXxx/subtest 格式）
+        if '/' in test_name:
+            main_test = test_name.split('/')[0]
+            if func_name == main_test:
+                return True
+        
+        return False
+    
+    def restore_all(self) -> List[str]:
+        """恢复所有修改"""
+        restored = self.backup_manager.restore_all()
+        self.deleted_tests.clear()
+        return restored
+    
+    def cleanup(self):
+        """清理资源"""
+        self.backup_manager.cleanup()