coverage-tool 1.0.0__py3-none-any.whl

coverage_tool/parsers/junit.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+JUnit XML 解析器
+解析各语言生成的JUnit XML测试报告
+"""
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+from enum import Enum
+from pathlib import Path
+
+class TestStatus(Enum):
+    PASSED = "passed"
+    FAILED = "failed"
+    ERROR = "error"
+    SKIPPED = "skipped"
+
+@dataclass
+class TestCase:
+    """单个测试用例"""
+    name: str
+    classname: str
+    time: float
+    status: TestStatus
+    failure_message: Optional[str] = None
+    failure_type: Optional[str] = None
+    error_message: Optional[str] = None
+    error_type: Optional[str] = None
+    skipped_message: Optional[str] = None
+
+@dataclass
+class TestSuite:
+    """测试套件"""
+    name: str
+    tests: int
+    failures: int
+    errors: int
+    skipped: int
+    time: float
+    test_cases: List[TestCase] = field(default_factory=list)
+
+@dataclass
+class TestReport:
+    """完整测试报告"""
+    suites: List[TestSuite]
+    total_tests: int = 0
+    total_failures: int = 0
+    total_errors: int = 0
+    total_skipped: int = 0
+    total_time: float = 0.0
+
+    def __post_init__(self):
+        for suite in self.suites:
+            self.total_tests += suite.tests
+            self.total_failures += suite.failures
+            self.total_errors += suite.errors
+            self.total_skipped += suite.skipped
+            self.total_time += suite.time
+
+    @property
+    def pass_rate(self) -> float:
+        if self.total_tests == 0:
+            return 0.0
+        passed = self.total_tests - self.total_failures - self.total_errors - self.total_skipped
+        return (passed / self.total_tests) * 100
+
+class JunitXMLParser:
+    """JUnit XML解析器"""
+
+    @staticmethod
+    def parse(xml_path: str) -> TestReport:
+        """解析JUnit XML文件"""
+        tree = ET.parse(xml_path)
+        root = tree.getroot()
+
+        # 兼容不同格式的根节点
+        if root.tag == 'testsuites':
+            return JunitXMLParser._parse_testsuites(root)
+        elif root.tag == 'testsuite':
+            return JunitXMLParser._parse_testsuite(root)
+        else:
+            raise ValueError(f"未知的XML根节点: {root.tag}")
+
+    @staticmethod
+    def _parse_testsuites(root: ET.Element) -> TestReport:
+        """解析testsuites根节点"""
+        suites = []
+        for suite_elem in root.findall('testsuite'):
+            suite = JunitXMLParser._parse_single_testsuite(suite_elem)
+            suites.append(suite)
+        return TestReport(suites=suites)
+
+    @staticmethod
+    def _parse_testsuite(root: ET.Element) -> TestReport:
+        """解析testsuite根节点"""
+        suite = JunitXMLParser._parse_single_testsuite(root)
+        return TestReport(suites=[suite])
+
+    @staticmethod
+    def _parse_single_testsuite(suite_elem: ET.Element) -> TestSuite:
+        """解析单个testsuite"""
+        name = suite_elem.get('name', '')
+        tests = int(suite_elem.get('tests', 0))
+        failures = int(suite_elem.get('failures', 0))
+        errors = int(suite_elem.get('errors', 0))
+        skipped = int(suite_elem.get('skipped', 0))
+        time = float(suite_elem.get('time', 0.0))
+
+        test_cases = []
+        for case_elem in suite_elem.findall('testcase'):
+            test_case = JunitXMLParser._parse_testcase(case_elem)
+            test_cases.append(test_case)
+
+        return TestSuite(
+            name=name,
+            tests=tests,
+            failures=failures,
+            errors=errors,
+            skipped=skipped,
+            time=time,
+            test_cases=test_cases
+        )
+
+    @staticmethod
+    def _parse_testcase(case_elem: ET.Element) -> TestCase:
+        """解析单个testcase"""
+        name = case_elem.get('name', '')
+        classname = case_elem.get('classname', '')
+        time = float(case_elem.get('time', 0.0))
+
+        # 检查状态
+        failure_elem = case_elem.find('failure')
+        error_elem = case_elem.find('error')
+        skipped_elem = case_elem.find('skipped')
+
+        if failure_elem is not None:
+            status = TestStatus.FAILED
+            failure_message = failure_elem.get('message', '')
+            failure_type = failure_elem.get('type', '')
+        elif error_elem is not None:
+            status = TestStatus.ERROR
+            error_message = error_elem.get('message', '')
+            error_type = error_elem.get('type', '')
+        elif skipped_elem is not None:
+            status = TestStatus.SKIPPED
+            skipped_message = skipped_elem.get('message', '')
+        else:
+            status = TestStatus.PASSED
+
+        return TestCase(
+            name=name,
+            classname=classname,
+            time=time,
+            status=status,
+            failure_message=failure_elem.get('message') if failure_elem else None,
+            failure_type=failure_elem.get('type') if failure_elem else None,
+            error_message=error_elem.get('message') if error_elem else None,
+            error_type=error_elem.get('type') if error_elem else None,
+            skipped_message=skipped_elem.get('message') if skipped_elem else None
+        )
+
+    @staticmethod
+    def parse_string(xml_string: str) -> TestReport:
+        """从字符串解析JUnit XML"""
+        root = ET.fromstring(xml_string)
+        if root.tag == 'testsuites':
+            return JunitXMLParser._parse_testsuites(root)
+        elif root.tag == 'testsuite':
+            return JunitXMLParser._parse_testsuite(root)
+        else:
+            raise ValueError(f"未知的XML根节点: {root.tag}")

coverage_tool/runners/__init__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+多语言单测运行器包
+支持 Python, Java, Go, C, C++
+统一覆盖率计算和增强错误处理
+"""
+
+from .base import RunResult, BaseRunner, CoverageExtractor
+from .factory import RunnerFactory
+from .python_runner import PythonRunner
+from .java_runner import JavaRunner
+from .go_runner import GoRunner
+from .c_runner import CRunner
+from .cpp_runner import CPPRunner
+
+__all__ = [
+    'RunResult',
+    'BaseRunner', 
+    'CoverageExtractor',
+    'RunnerFactory',
+    'PythonRunner',
+    'JavaRunner',
+    'GoRunner',
+    'CRunner',
+    'CPPRunner',
+]

coverage_tool/runners/base.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+运行器基类和共享组件
+"""
+
+import subprocess
+import os
+import time
+import re
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Tuple, Any
+from pathlib import Path
+from dataclasses import dataclass
+
+from coverage_tool.core import CoverageConfig
+from coverage_tool.utils import Logger
+
+
+@dataclass
+class RunResult:
+    """运行结果"""
+    success: bool
+    return_code: int
+    stdout: str
+    stderr: str
+    duration: float
+    junit_xml_path: Optional[str] = None
+    coverage_rate: float = 0.0
+
+
+class CoverageExtractor:
+    """覆盖率提取器 - 统一处理不同语言的覆盖率"""
+    
+    @staticmethod
+    def extract_from_coverage_out(coverage_out_path: str, language: str) -> float:
+        """从coverage.out文件提取覆盖率"""
+        if not os.path.exists(coverage_out_path):
+            return 0.0
+        
+        try:
+            if language == 'go':
+                return CoverageExtractor._extract_go_coverage(coverage_out_path)
+            elif language in ['c', 'cpp']:
+                return CoverageExtractor._extract_gcov_coverage(coverage_out_path)
+            else:
+                return CoverageExtractor._extract_generic_coverage(coverage_out_path)
+        except Exception as e:
+            print(f"提取覆盖率失败: {e}")
+            return 0.0
+    
+    @staticmethod
+    def _extract_go_coverage(coverage_out_path: str) -> float:
+        """提取Go覆盖率"""
+        # 使用 go tool cover
+        result = subprocess.run(
+            f"go tool cover -func={coverage_out_path}",
+            shell=True,
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode == 0:
+            for line in result.stdout.split('\n'):
+                if 'total:' in line.lower():
+                    parts = line.split()
+                    for part in reversed(parts):
+                        if '%' in part:
+                            try:
+                                return float(part.replace('%', ''))
+                            except:
+                                pass
+        
+        # 备用方案：直接解析文件
+        return CoverageExtractor._parse_go_coverage_file(coverage_out_path)
+    
+    @staticmethod
+    def _parse_go_coverage_file(coverage_out_path: str) -> float:
+        """直接解析Go coverage.out文件"""
+        try:
+            with open(coverage_out_path, 'r') as f:
+                lines = f.readlines()
+            
+            if not lines or not lines[0].startswith('mode:'):
+                return 0.0
+            
+            total_statements = 0
+            executed_statements = 0
+            
+            for line in lines[1:]:
+                parts = line.strip().split()
+                if len(parts) >= 3:
+                    try:
+                        hits = int(parts[-1])
+                        total_statements += 1
+                        if hits > 0:
+                            executed_statements += 1
+                    except:
+                        continue
+            
+            if total_statements > 0:
+                return (executed_statements / total_statements) * 100
+        except Exception as e:
+            print(f"解析Go覆盖率文件失败: {e}")
+        
+        return 0.0
+    
+    @staticmethod
+    def _extract_gcov_coverage(coverage_out_path: str) -> float:
+        """提取gcov覆盖率"""
+        try:
+            with open(coverage_out_path, 'r') as f:
+                content = f.read()
+            
+            # 尝试多种模式匹配
+            patterns = [
+                r'lines[\s\w:]+(\d+\.?\d*)%',
+                r'Total[\s\w:]+(\d+\.?\d*)%',
+                r'(\d+\.?\d*)%',
+            ]
+            
+            for pattern in patterns:
+                match = re.search(pattern, content, re.IGNORECASE)
+                if match:
+                    try:
+                        return float(match.group(1))
+                    except:
+                        continue
+        except Exception as e:
+            print(f"提取gcov覆盖率失败: {e}")
+        
+        return 0.0
+    
+    @staticmethod
+    def _extract_generic_coverage(coverage_out_path: str) -> float:
+        """通用覆盖率提取"""
+        try:
+            with open(coverage_out_path, 'r') as f:
+                content = f.read()
+            
+            # 查找百分比
+            match = re.search(r'(\d+\.?\d*)%', content)
+            if match:
+                return float(match.group(1))
+        except Exception as e:
+            print(f"提取覆盖率失败: {e}")
+        
+        return 0.0
+    
+    @staticmethod
+    def extract_from_jacoco(jacoco_html_path: str) -> float:
+        """从JaCoCo HTML报告提取覆盖率"""
+        if not os.path.exists(jacoco_html_path):
+            return 0.0
+        
+        try:
+            with open(jacoco_html_path, 'r') as f:
+                content = f.read()
+            
+            # 查找Total行中的覆盖率
+            match = re.search(r'Total.*?(\d+)%<', content, re.DOTALL)
+            if match:
+                return float(match.group(1))
+        except Exception as e:
+            print(f"提取JaCoCo覆盖率失败: {e}")
+        
+        return 0.0
+
+
+class BaseRunner(ABC):
+    """单测运行器基类"""
+    
+    def __init__(self, config: CoverageConfig, logger: Optional[Logger] = None):
+        self.config = config
+        self.logger = logger or Logger()
+    
+    @abstractmethod
+    def run_tests(self, target_dir: str, output_file: str) -> RunResult:
+        """运行测试"""
+        pass
+    
+    @abstractmethod
+    def get_coverage(self, output_file: str) -> float:
+        """获取覆盖率"""
+        pass
+    
+    @abstractmethod
+    def compile(self, target_dir: str) -> Tuple[bool, List[str]]:
+        """编译项目"""
+        pass
+    
+    def find_files(self, target_dir: str, pattern: str) -> List[str]:
+        """查找文件"""
+        # 清理模式：移除开头的 **/ 或 **，确保是相对模式
+        clean_pattern = pattern
+        if clean_pattern.startswith("**/"):
+            clean_pattern = clean_pattern[3:]
+        elif clean_pattern.startswith("**"):
+            clean_pattern = clean_pattern[2:]
+        
+        # 确保模式不为空且是相对路径
+        if not clean_pattern or clean_pattern.startswith("/"):
+            clean_pattern = "*" + clean_pattern if clean_pattern else "*"
+        
+        try:
+            return [str(p) for p in Path(target_dir).rglob(clean_pattern) if p.is_file()]
+        except Exception as e:
+            self.logger.error(f"查找文件失败: {e}")
+            return []
+    
+    def _run_command(self, cmd: str, cwd: str, timeout: int = 300) -> RunResult:
+        """执行命令"""
+        start_time = time.time()
+        try:
+            result = subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                cwd=cwd,
+                timeout=timeout
+            )
+            duration = time.time() - start_time
+            return RunResult(
+                success=result.returncode == 0,
+                return_code=result.returncode,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                duration=duration
+            )
+        except subprocess.TimeoutExpired:
+            duration = time.time() - start_time
+            self.logger.error(f"命令执行超时: {cmd}")
+            return RunResult(
+                success=False,
+                return_code=-1,
+                stdout="",
+                stderr=f"命令执行超时（{timeout}秒）",
+                duration=duration
+            )
+        except Exception as e:
+            duration = time.time() - start_time
+            self.logger.error(f"命令执行异常: {e}")
+            return RunResult(
+                success=False,
+                return_code=-1,
+                stdout="",
+                stderr=str(e),
+                duration=duration
+            )

coverage_tool/runners/c_runner.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+C单测运行器
+"""
+
+import os
+from typing import List
+
+from coverage_tool.converters import JUnitReportConverter
+from .base import BaseRunner, RunResult, CoverageExtractor
+
+
+class CRunner(BaseRunner):
+    """C单测运行器"""
+    
+    def run_tests(self, target_dir: str, output_file: str) -> RunResult:
+        """运行C测试"""
+        # 尝试使用make运行测试
+        cmd = "make test"
+        result = self._run_command(cmd, target_dir)
+        
+        # 尝试转换输出为JUnit XML
+        if result.stdout or result.stderr:
+            try:
+                xml_content = JUnitReportConverter.convert_generic_output(
+                    result.stdout + result.stderr, 'cunit'
+                )
+                with open(output_file, 'w') as f:
+                    f.write(xml_content)
+                result.junit_xml_path = output_file
+            except Exception as e:
+                self.logger.error(f"转换C测试输出失败: {e}")
+        
+        result.coverage_rate = self.get_coverage(output_file)
+        
+        return result
+    
+    def get_coverage(self, output_file: str) -> float:
+        """获取C覆盖率（gcov）"""
+        # 查找gcov输出文件
+        temp_dir = os.path.dirname(output_file) if output_file else "."
+        
+        coverage_files = [
+            os.path.join(temp_dir, "coverage.out"),
+            os.path.join(temp_dir, "coverage.txt"),
+            os.path.join(os.getcwd(), "coverage.out"),
+        ]
+        
+        for cov_file in coverage_files:
+            if os.path.exists(cov_file):
+                return CoverageExtractor.extract_from_coverage_out(cov_file, 'c')
+        
+        return 0.0
+    
+    def compile(self, target_dir: str) -> tuple[bool, list[str]]:
+        """编译C项目"""
+        cmd = "make"
+        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 'undefined reference' in line.lower():
+                    errors.append(line.strip())
+        
+        return result.success, errors

coverage_tool/runners/cpp_runner.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+C++单测运行器
+"""
+
+import os
+from typing import List
+
+from coverage_tool.converters import JUnitReportConverter
+from .base import BaseRunner, RunResult, CoverageExtractor
+
+
+class CPPRunner(BaseRunner):
+    """C++单测运行器"""
+    
+    def run_tests(self, target_dir: str, output_file: str) -> RunResult:
+        """运行C++测试"""
+        # 尝试使用make运行测试
+        cmd = "make test"
+        result = self._run_command(cmd, target_dir)
+        
+        # 尝试转换输出为JUnit XML
+        if result.stdout or result.stderr:
+            try:
+                xml_content = JUnitReportConverter.convert_generic_output(
+                    result.stdout + result.stderr, 'gtest'
+                )
+                with open(output_file, 'w') as f:
+                    f.write(xml_content)
+                result.junit_xml_path = output_file
+            except Exception as e:
+                self.logger.error(f"转换C++测试输出失败: {e}")
+        
+        result.coverage_rate = self.get_coverage(output_file)
+        
+        return result
+    
+    def get_coverage(self, output_file: str) -> float:
+        """获取C++覆盖率（gcov/lcov）"""
+        temp_dir = os.path.dirname(output_file) if output_file else "."
+        
+        coverage_files = [
+            os.path.join(temp_dir, "coverage.out"),
+            os.path.join(temp_dir, "coverage.txt"),
+            os.path.join(os.getcwd(), "coverage.out"),
+        ]
+        
+        for cov_file in coverage_files:
+            if os.path.exists(cov_file):
+                return CoverageExtractor.extract_from_coverage_out(cov_file, 'cpp')
+        
+        return 0.0
+    
+    def compile(self, target_dir: str) -> tuple[bool, list[str]]:
+        """编译C++项目"""
+        cmd = "make"
+        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 'undefined reference' in line.lower():
+                    errors.append(line.strip())
+        
+        return result.success, errors

coverage_tool/runners/factory.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""
+运行器工厂
+"""
+
+from typing import Optional
+
+from coverage_tool.core import Language, LANGUAGE_CONFIGS
+from coverage_tool.utils import Logger
+from .base import BaseRunner
+from .python_runner import PythonRunner
+from .java_runner import JavaRunner
+from .go_runner import GoRunner
+from .c_runner import CRunner
+from .cpp_runner import CPPRunner
+
+
+class RunnerFactory:
+    """运行器工厂"""
+    
+    _runners = {
+        Language.PYTHON: PythonRunner,
+        Language.JAVA: JavaRunner,
+        Language.GO: GoRunner,
+        Language.C: CRunner,
+        Language.CPP: CPPRunner,
+    }
+    
+    @classmethod
+    def get_runner(cls, language: Language, logger: Optional[Logger] = None) -> BaseRunner:
+        """获取对应语言的运行器"""
+        config = LANGUAGE_CONFIGS[language]
+        runner_class = cls._runners.get(language)
+        if runner_class is None:
+            raise ValueError(f"不支持的语言: {language}")
+        return runner_class(config, logger)
+    
+    @classmethod
+    def register_runner(cls, language: Language, runner_class: type):
+        """注册新的运行器"""
+        cls._runners[language] = runner_class