coverage-tool 1.0.0__py3-none-any.whl

coverage_tool/converters/cunit_converter.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+CUnit 测试输出转换器
+"""
+
+import re
+
+from .base import BaseConverter, TestCaseResult
+
+
+class CUnitConverter(BaseConverter):
+    """CUnit 测试输出转换器"""
+
+    @staticmethod
+    def convert(cunit_output: str) -> str:
+        """转换 CUnit 输出为 JUnit XML"""
+        test_cases = []
+
+        # CUnit 输出解析
+        pattern = re.compile(
+            r'(PASS|FAIL|SKIP):\s+(\w+)\s+\(([^)]+)\)',
+            re.MULTILINE
+        )
+
+        for match in pattern.finditer(cunit_output):
+            status, name, message = match.groups()
+
+            case = TestCaseResult(
+                name=name,
+                classname="cunit",
+                time=0.0,
+                passed=status == 'PASS',
+                skipped=status == 'SKIP'
+            )
+
+            if status == 'FAIL':
+                case.passed = False
+                case.failed_message = message
+                case.failed_type = 'failure'
+
+            test_cases.append(case)
+
+        return CUnitConverter._create_junit_xml(
+            "CUnit Tests",
+            test_cases,
+            0.0
+        )

coverage_tool/converters/factory.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+转换器工厂
+"""
+
+from typing import Dict, Type
+
+from .base import BaseConverter
+from .go_converter import GoTestConverter
+from .gtest_converter import GTestConverter
+from .cunit_converter import CUnitConverter
+from .generic_converter import GenericConverter
+
+
+class ConverterFactory:
+    """转换器工厂"""
+
+    _converters: Dict[str, Type[BaseConverter]] = {
+        'go': GoTestConverter,
+        'gtest': GTestConverter,
+        'google': GTestConverter,
+        'cunit': CUnitConverter,
+    }
+
+    @classmethod
+    def get_converter(cls, test_framework: str):
+        """获取对应测试框架的转换器"""
+        converter_class = cls._converters.get(test_framework)
+        if converter_class is None:
+            return GenericConverter
+        return converter_class
+
+    @classmethod
+    def register_converter(cls, test_framework: str, converter_class: type):
+        """注册新的转换器"""
+        cls._converters[test_framework] = converter_class

coverage_tool/converters/generic_converter.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+通用测试输出转换器
+"""
+
+import re
+from typing import List
+
+from .base import BaseConverter, TestCaseResult
+from .go_converter import GoTestConverter
+from .gtest_converter import GTestConverter
+from .cunit_converter import CUnitConverter
+
+
+class GenericConverter(BaseConverter):
+    """通用测试输出转换器"""
+
+    @staticmethod
+    def convert(output: str, test_framework: str) -> str:
+        """通用测试输出转换"""
+        test_cases: List[TestCaseResult] = []
+
+        if test_framework == 'go':
+            return GoTestConverter.convert(output)
+        elif test_framework in ['gtest', 'google']:
+            return GTestConverter.convert(output, '')
+        elif test_framework == 'cunit':
+            return CUnitConverter.convert(output)
+
+        # 通用解析：查找 PASS/FAIL 模式
+        patterns = {
+            'PASS': r'PASS:\s+(\w+)',
+            'FAIL': r'FAIL:\s+(\w+)',
+            'OK': r'OK\s+-\s+(\w+)',
+            'ERROR': r'ERROR\s+-\s+(\w+)',
+        }
+
+        passed_tests = []
+        failed_tests = []
+
+        for status, pattern in patterns.items():
+            matches = re.findall(pattern, output)
+            if 'PASS' in status:
+                passed_tests.extend(matches)
+            elif 'FAIL' in status or 'ERROR' in status:
+                failed_tests.extend(matches)
+
+        test_cases.extend([
+            TestCaseResult(name=name, classname="test", time=0.0, passed=True)
+            for name in passed_tests
+        ])
+        test_cases.extend([
+            TestCaseResult(name=name, classname="test", time=0.0, passed=False,
+                          failed_message="Test failed", failed_type='failure')
+            for name in failed_tests
+        ])
+
+        return GenericConverter._create_junit_xml(
+            f"{test_framework.title()} Tests",
+            test_cases,
+            0.0
+        )

coverage_tool/converters/go_converter.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+Go 测试输出转换器
+"""
+
+import json
+import subprocess
+import os
+from typing import Optional
+
+from .base import BaseConverter, TestCaseResult
+
+
+class GoTestConverter(BaseConverter):
+    """Go 测试输出转换器"""
+
+    @staticmethod
+    def convert(go_test_output: str, coverage_out: Optional[str] = None) -> str:
+        """将 Go test JSON 输出转换为 JUnit XML"""
+        test_cases = []
+        total_time = 0.0
+        current_test = {}
+
+        try:
+            # Go test JSON 输出是 NDJSON 格式（每行一个JSON对象）
+            for line in go_test_output.strip().split('\n'):
+                if not line.strip():
+                    continue
+                data = json.loads(line)
+                event = data.get('Action', '')  # Go test 使用 Action 字段
+
+                # 处理测试开始/运行事件
+                if event in ['start', 'run']:
+                    test_name = data.get('Test', '')
+                    if isinstance(test_name, dict):
+                        test_name = test_name.get('Name', '')
+                    if test_name:
+                        current_test = {
+                            'name': test_name,
+                            'package': data.get('Package', 'main'),
+                            'elapsed': data.get('Elapsed', 0),
+                        }
+
+                # 处理测试结果
+                elif event == 'pass':
+                    if current_test.get('name'):
+                        case = TestCaseResult(
+                            name=current_test['name'],
+                            classname=current_test.get('package', 'main'),
+                            time=float(current_test.get('elapsed', 0)),
+                            passed=True
+                        )
+                        test_cases.append(case)
+                        total_time += case.time
+                    current_test = {}
+
+                # 处理测试失败
+                elif event == 'fail':
+                    if current_test.get('name'):
+                        case = TestCaseResult(
+                            name=current_test['name'],
+                            classname=current_test.get('package', 'main'),
+                            time=float(current_test.get('elapsed', 0)),
+                            passed=False,
+                            failed_message=data.get('Output', 'Test failed'),
+                            failed_type='failure'
+                        )
+                        test_cases.append(case)
+                        total_time += case.time
+                    current_test = {}
+
+                # 处理测试跳过
+                elif event == 'skip':
+                    if current_test.get('name'):
+                        case = TestCaseResult(
+                            name=current_test['name'],
+                            classname=current_test.get('package', 'main'),
+                            time=float(current_test.get('elapsed', 0)),
+                            skipped=True,
+                            skipped_message=data.get('Skip', '')
+                        )
+                        test_cases.append(case)
+                        total_time += case.time
+                    current_test = {}
+
+        except json.JSONDecodeError:
+            return GoTestConverter._create_basic_junit_xml(
+                "Go Test",
+                [TestCaseResult(name="Parse Error", classname="go_test", time=0, passed=False,
+                               failed_message="Failed to parse test output")]
+            )
+
+        return GoTestConverter._create_junit_xml(
+            "Go Tests",
+            test_cases,
+            total_time
+        )
+
+
+class GoJUnitReportTool:
+    """Go 测试 JUnit 报告工具"""
+
+    @staticmethod
+    def ensure_tool_installed() -> bool:
+        """确保 go-junit-report 工具已安装"""
+        # 检查是否已安装
+        result = subprocess.run(
+            ["which", "go-junit-report"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            return True
+
+        # 尝试安装
+        print("正在安装 go-junit-report...")
+        install_result = subprocess.run(
+            ["go", "install", "github.com/jstemmer/go-junit-report@latest"],
+            capture_output=True,
+            text=True,
+            timeout=120
+        )
+
+        if install_result.returncode == 0:
+            # 添加到 PATH
+            go_path = subprocess.run(
+                ["go", "env", "GOPATH"],
+                capture_output=True,
+                text=True
+            ).stdout.strip()
+
+            gopath_bin = os.path.join(go_path, "bin")
+            if gopath_bin not in os.environ.get('PATH', ''):
+                os.environ['PATH'] = f"{gopath_bin}:{os.environ.get('PATH', '')}"
+
+            print("✓ go-junit-report 安装成功")
+            return True
+        else:
+            print(f"✗ go-junit-report 安装失败: {install_result.stderr}")
+            return False
+
+    @staticmethod
+    def generate_report(go_test_output: str, xml_path: str) -> bool:
+        """使用 go-junit-report 生成报告"""
+        # 先确保工具已安装
+        if not GoJUnitReportTool.ensure_tool_installed():
+            return False
+
+        try:
+            report_cmd = [
+                "go-junit-report",
+                "-xmlout", xml_path
+            ]
+
+            result = subprocess.run(
+                report_cmd,
+                input=go_test_output,
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+
+            if result.returncode == 0 and os.path.exists(xml_path):
+                return True
+
+            if result.returncode != 0:
+                print(f"go-junit-report 错误: {result.stderr}")
+        except FileNotFoundError:
+            print("go-junit-report 未找到，尝试使用内置转换...")
+        except Exception as e:
+            print(f"go-junit-report 执行错误: {e}")
+
+        return False
+
+    @staticmethod
+    def manual_convert(go_test_output: str, xml_path: str) -> str:
+        """手动将 Go test 输出转换为 JUnit XML（备用方案）"""
+        return GoTestConverter.convert(go_test_output)

coverage_tool/converters/gtest_converter.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+Google Test 输出转换器
+"""
+
+import os
+import re
+
+from .base import BaseConverter, TestCaseResult
+
+
+class GTestConverter(BaseConverter):
+    """Google Test 输出转换器"""
+
+    @staticmethod
+    def convert(gtest_output: str, xml_path: str) -> str:
+        """转换 Google Test 输出为 JUnit XML"""
+        # Google Test 支持直接输出 XML
+        # 如果已经有 XML 文件，直接返回
+        if os.path.exists(xml_path):
+            with open(xml_path, 'r') as f:
+                return f.read()
+
+        # 解析文本输出
+        test_cases = []
+        total_time = 0.0
+
+        # Google Test 输出格式解析
+        pattern = re.compile(
+            r'\[(?:PASSED|FAILED|SKIPPED)\]\s+(?:\[.*?\]\s+)?(\w+)\s+\(([^)]+)\)',
+            re.MULTILINE
+        )
+
+        for match in pattern.finditer(gtest_output):
+            status = match.group(0)
+            name = match.group(1)
+            details = match.group(2)
+
+            case = TestCaseResult(
+                name=name,
+                classname="gtest",
+                time=0.0,
+                passed="PASSED" in status,
+                skipped="SKIPPED" in status
+            )
+
+            if "PASSED" in status:
+                case.passed = True
+            elif "FAILED" in status:
+                case.passed = False
+                case.failed_message = details
+                case.failed_type = 'failure'
+            elif "SKIPPED" in status:
+                case.skipped = True
+                case.skipped_message = details
+
+            test_cases.append(case)
+
+        return GTestConverter._create_junit_xml(
+            "Google Tests",
+            test_cases,
+            total_time
+        )

coverage_tool/core/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""
+核心模块包
+包含配置、主程序和报告生成等核心功能
+"""
+
+from .config import Language, CoverageConfig, LANGUAGE_CONFIGS
+from .reporter import CoverageReporter, CoverageReport, CoverageStats, ReportFormat
+
+__all__ = [
+    'Language',
+    'CoverageConfig', 
+    'LANGUAGE_CONFIGS',
+    'CoverageReporter',
+    'CoverageReport',
+    'CoverageStats',
+    'ReportFormat',
+]

coverage_tool/core/config.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+多语言单测统计工具配置
+支持 Python, Java, Go, C, C++
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+from enum import Enum
+
+class Language(Enum):
+    PYTHON = "python"
+    JAVA = "java"
+    GO = "go"
+    C = "c"
+    CPP = "cpp"
+
+@dataclass
+class CoverageConfig:
+    """单测覆盖率配置"""
+    language: Language
+    test_command: str
+    coverage_command: str
+    test_file_pattern: str
+    source_file_pattern: str
+    output_format: str = "junit"
+    coverage_output: str = "coverage.xml"
+
+# 各语言配置
+LANGUAGE_CONFIGS: Dict[Language, CoverageConfig] = {
+    Language.PYTHON: CoverageConfig(
+        language=Language.PYTHON,
+        test_command="python -m pytest --junitxml={junit_output}",
+        coverage_command="python -m coverage run --source={source} -m pytest --junitxml={junit_output}",
+        test_file_pattern="**/*test*.py",
+        source_file_pattern="**/*.py"
+    ),
+    Language.JAVA: CoverageConfig(
+        language=Language.JAVA,
+        test_command="mvn test -Dreport=XML",
+        coverage_command="mvn test jacoco:report -Dreport=XML",
+        test_file_pattern="**/*Test.java",
+        source_file_pattern="**/*.java"
+    ),
+    Language.GO: CoverageConfig(
+        language=Language.GO,
+        test_command="go test -v -cover -coverprofile=coverage.out {packages}",
+        coverage_command="go test -v -cover -coverprofile=coverage.out {packages}",
+        test_file_pattern="**/*_test.go",
+        source_file_pattern="**/*.go"
+    ),
+    Language.C: CoverageConfig(
+        language=Language.C,
+        test_command="make test",
+        coverage_command="make coverage",
+        test_file_pattern="**/test_*.c,**/*_test.c,**/*test*.c,**/check_*.c,**/tests/*.c",
+        source_file_pattern="**/*.c"
+    ),
+    Language.CPP: CoverageConfig(
+        language=Language.CPP,
+        test_command="make test",
+        coverage_command="make coverage",
+        test_file_pattern="**/test_*.cpp,**/*_test.cpp,**/*test*.cpp,**/Test*.cpp,**/*.test.cpp,**/*.cc",
+        source_file_pattern="**/*.cpp,**/*.cc,**/*.hpp"
+    )
+}