spl-core 7.14.0rc4.dev3__tar.gz → 7.15.0rc1__tar.gz

{spl_core-7.14.0rc4.dev3 → spl_core-7.15.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spl-core
-Version: 7.14.0rc4.dev3
+Version: 7.15.0rc1
 Summary: Software Product Line Support for CMake
 License: MIT
 License-File: LICENSE
@@ -20,6 +20,7 @@ Requires-Dist: cookiecutter (==2.6.0)
 Requires-Dist: doxysphinx (>=3.3,<4.0)
 Requires-Dist: gcovr (>=8.3,<9.0)
 Requires-Dist: hammocking (>=0.8,<0.10)
+Requires-Dist: junitparser
 Requires-Dist: kconfiglib (>=14.1,<15.0)
 Requires-Dist: mlx-traceability (>=10,<12)
 Requires-Dist: myst-parser (>=0.16)

{spl_core-7.14.0rc4.dev3 → spl_core-7.15.0rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "spl-core"
-version = "7.14.0-rc4.dev.3"
+version = "7.15.0-rc.1"
 description = "Software Product Line Support for CMake"
 authors = ["Avengineers <karsten.guenther@kamg.de>"]
 license = "MIT"
@@ -18,6 +18,7 @@ packages = [{ include = "spl_core", from = "src" }]
 
 [tool.poetry.scripts]
 please = "spl_core.main:main"
+junit_merger = "spl_core.test_utils.junit_merger:main"
 
 [tool.poetry.urls]
 "Bug Tracker" = "https://github.com/avengineers/spl-core/issues"
@@ -49,6 +50,7 @@ sphinx-design = ">=0.5,<0.7"
 pypeline-semantic-release = ">=0.4.1,<=0.5.0"
 pypeline-runner = ">=1,<=2"
 py7zr = "^1.0.0"
+junitparser = "*"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=7,<9"
@@ -57,7 +59,6 @@ pre-commit = "^3.1.1"
 ruff = ">=0.5,<0.13"
 jinja2 = "*"
 testfixtures = "*"
-junitparser = "*"
 mashumaro = "*"
 loguru = "*"
 flake8 = "*"

spl_core-7.15.0rc1/src/spl_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "7.15.0-rc.1"

{spl_core-7.14.0rc4.dev3 → spl_core-7.15.0rc1}/src/spl_core/common.cmake

@@ -606,15 +606,36 @@ set(COV_OUT_JSON coverage.json)
 function(_spl_coverage_create_overall_report)
     if(_SPL_COVERAGE_CREATE_OVERALL_REPORT_IS_NECESSARY)
         set(COV_OUT_VARIANT_HTML reports/coverage/index.html)
+        set(COV_OUT_VARIANT_JSON variant-coverage.json)
+        set(JUNIT_OUT_VARIANT_XML variant-junit.xml)
+
+        # Generate variant-level merged coverage JSON
+        add_custom_command(
+            OUTPUT ${COV_OUT_VARIANT_JSON}
+            COMMAND gcovr --root ${CMAKE_SOURCE_DIR} --add-tracefile \"${CMAKE_CURRENT_BINARY_DIR}/**/${COV_OUT_JSON}\" --json --output ${COV_OUT_VARIANT_JSON}
+            DEPENDS ${GLOBAL_COMPONENTS_COVERAGE_JSON_LIST}
+            COMMENT "Generating variant-level merged coverage JSON ${COV_OUT_VARIANT_JSON} ..."
+        )
+
+        # Generate variant-level merged JUnit XML
+        add_custom_command(
+            OUTPUT ${JUNIT_OUT_VARIANT_XML}
+            COMMAND junit_merger --output ${JUNIT_OUT_VARIANT_XML} --inputs ${GLOBAL_COMPONENTS_JUNIT_XML_LIST}
+            DEPENDS ${GLOBAL_COMPONENTS_JUNIT_XML_LIST}
+            COMMENT "Generating variant-level merged JUnit XML ${JUNIT_OUT_VARIANT_XML} ..."
+        )
+
+        # Generate variant-level HTML coverage report
         add_custom_command(
             OUTPUT ${COV_OUT_VARIANT_HTML}
             COMMAND gcovr --root ${CMAKE_SOURCE_DIR} --add-tracefile \"${CMAKE_CURRENT_BINARY_DIR}/**/${COV_OUT_JSON}\" --html --html-details --output ${COV_OUT_VARIANT_HTML}
             DEPENDS ${GLOBAL_COMPONENTS_COVERAGE_JSON_LIST}
             COMMENT "Generating overall code coverage report ${COV_OUT_VARIANT_HTML} ..."
         )
+
         add_custom_target(
             unittests
-            DEPENDS coverage ${COV_OUT_VARIANT_HTML}
+            DEPENDS coverage ${COV_OUT_VARIANT_HTML} ${COV_OUT_VARIANT_JSON} ${JUNIT_OUT_VARIANT_XML}
         )
         add_custom_target(
             coverage_overall_report
@@ -718,6 +739,7 @@ macro(_spl_add_test_suite COMPONENT_NAME PROD_SRC TEST_SOURCES)
         DEPENDS ${exe_name}
     )
 
+    set(GLOBAL_COMPONENTS_JUNIT_XML_LIST "${GLOBAL_COMPONENTS_JUNIT_XML_LIST};${CMAKE_CURRENT_BINARY_DIR}/${TEST_OUT_JUNIT}" CACHE INTERNAL "List of all ${TEST_OUT_JUNIT} files")
     set(GLOBAL_COMPONENTS_COVERAGE_JSON_LIST "${GLOBAL_COMPONENTS_COVERAGE_JSON_LIST};${CMAKE_CURRENT_BINARY_DIR}/${COV_OUT_JSON}" CACHE INTERNAL "List of all ${COV_OUT_JSON} files")
 
     # Create coverage results (coverage.json)

{spl_core-7.14.0rc4.dev3 → spl_core-7.15.0rc1}/src/spl_core/test_utils/artifacts_archiver.py

@@ -3,9 +3,45 @@ import os
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import py7zr
+from py_app_dev.core.logging import logger
+from py_app_dev.core.subprocess import SubprocessExecutor
+
+
+@dataclass
+class BuildMetadata:
+    """
+    Contains build metadata extracted from environment variables.
+
+    Attributes:
+        branch_name: The branch name, PR identifier (e.g., "PR-123"), or tag name
+        build_number: The build number or "local_build"
+        is_tag: Whether this is a tag build
+        pr_number: The PR number (without "PR-" prefix) for pull request builds, None otherwise
+    """
+
+    branch_name: str
+    build_number: str
+    is_tag: bool
+    pr_number: Optional[str]
+
+
+@dataclass
+class GitMetadata:
+    """
+    Contains git metadata extracted from environment variables or git commands.
+
+    Attributes:
+        commit_id: The git commit SHA (full hash)
+        commit_message: The git commit message subject line (first line only)
+        repository_url: The git repository URL (from remote.origin.url)
+    """
+
+    commit_id: Optional[str]
+    commit_message: Optional[str]
+    repository_url: Optional[str]
 
 
 class ArtifactsArchive:
@@ -84,7 +120,7 @@ class ArtifactsArchive:
             archive_path.unlink()
 
         if not self.archive_artifacts:
-            print("Warning: No artifacts registered for archiving")
+            logger.warning("No artifacts registered for archiving")
             # Create empty 7z file
             with py7zr.SevenZipFile(archive_path, "w") as archive:
                 pass
@@ -94,7 +130,7 @@ class ArtifactsArchive:
             with py7zr.SevenZipFile(archive_path, "w") as archive:
                 for artifact in self.archive_artifacts:
                     if not artifact.absolute_path.exists():
-                        print(f"Warning: Artifact {artifact.absolute_path} does not exist, skipping")
+                        logger.warning(f"Artifact {artifact.absolute_path} does not exist, skipping")
                         continue
 
                     try:
@@ -104,13 +140,13 @@ class ArtifactsArchive:
                             # py7zr can handle directories directly
                             archive.writeall(artifact.absolute_path, arcname=str(artifact.archive_path))
                     except Exception as file_error:
-                        print(f"Warning: Failed to add {artifact.absolute_path} to archive: {file_error}")
+                        logger.warning(f"Failed to add {artifact.absolute_path} to archive: {file_error}")
                         continue
 
-            print(f"7z file created at: {archive_path}")
+            logger.info(f"7z file created at: {archive_path}")
             return archive_path
         except Exception as e:
-            print(f"Error creating artifacts 7z file: {e}")
+            logger.error(f"Error creating artifacts 7z file: {e}")
             raise e
 
 
@@ -120,10 +156,10 @@ class ArtifactsArchiver:
     It provides a unified interface for registering artifacts to different archives.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, artifactory_base_url: Optional[str] = None) -> None:
         self.archives: Dict[str, ArtifactsArchive] = {}
         self._target_repos: Dict[str, str] = {}
-        # self._artifacts_metadata: Dict[str, Dict[str, Dict[str, str]]] = {}  # variant -> category -> artifacts
+        self.artifactory_base_url = artifactory_base_url
 
     def add_archive(self, out_dir: Path, archive_filename: str, target_repo: Optional[str] = None, archive_name: str = "default") -> ArtifactsArchive:
         """
@@ -190,7 +226,7 @@ class ArtifactsArchiver:
             The full Artifactory URL for the archive, or None if no target repo configured
 
         Example:
-            "https://artifactory.marquardt.de/artifactory/spled-generic-snapshot-rietheim/develop/123/Disco.7z"
+            "https://artifactory.example.com/artifactory/my-repo/results/develop/123/result.7z"
         """
         if archive_name not in self.archives:
             return None
@@ -198,12 +234,15 @@ class ArtifactsArchiver:
         if archive_name not in self._target_repos:
             return None
 
+        if self.artifactory_base_url is None:
+            return None
+
         archive = self.archives[archive_name]
         target_repo = self._target_repos[archive_name]
-        branch_name, build_number, _ = self._get_build_metadata()
+        metadata = self._get_build_metadata()
 
         # Construct the URL following the same pattern as create_rt_upload_json
-        archive_url = f"https://artifactory.marquardt.de/artifactory/{target_repo}/{branch_name}/{build_number}/{archive.archive_name}"
+        archive_url = f"{self.artifactory_base_url}/{target_repo}/{metadata.branch_name}/{metadata.build_number}/{archive.archive_name}"
 
         return archive_url
 
@@ -245,7 +284,7 @@ class ArtifactsArchiver:
             return 28  # 4 weeks for PRs, feature branches, and other branches
 
     @staticmethod
-    def _get_build_metadata() -> tuple[str, str, bool]:
+    def _get_build_metadata() -> BuildMetadata:
         """
         Get build metadata from environment variables or defaults.
 
@@ -253,14 +292,16 @@ class ArtifactsArchiver:
         to local development defaults.
 
         Returns:
-            Tuple of (branch_name, build_number, is_tag):
-            - branch_name: The branch or PR identifier
+            BuildMetadata instance containing:
+            - branch_name: The branch name, PR identifier (e.g., "PR-123"), or tag name
             - build_number: The build number or "local_build"
             - is_tag: Whether this is a tag build
+            - pr_number: The PR number (without "PR-" prefix) for pull requests, None otherwise
         """
         branch_name = "local_branch"
         build_number = "local_build"
         is_tag = False
+        pr_number = None
 
         if os.environ.get("JENKINS_URL"):
             change_id = os.environ.get("CHANGE_ID")
@@ -271,6 +312,7 @@ class ArtifactsArchiver:
             if change_id:
                 # Pull request case
                 branch_name = f"PR-{change_id}"
+                pr_number = change_id
             elif tag_name:
                 # Tag build case
                 branch_name = tag_name
@@ -282,7 +324,79 @@ class ArtifactsArchiver:
             if jenkins_build_number:
                 build_number = jenkins_build_number
 
-        return branch_name, build_number, is_tag
+        return BuildMetadata(
+            branch_name=branch_name,
+            build_number=build_number,
+            is_tag=is_tag,
+            pr_number=pr_number,
+        )
+
+    @staticmethod
+    def _get_git_metadata() -> GitMetadata:
+        """
+        Get git metadata from environment variables or git commands.
+
+        Attempts to retrieve git information in the following order:
+        1. Environment variables (GIT_COMMIT, GIT_URL) - typically set by Jenkins Git plugin
+        2. Git commands as fallback - executed locally using git CLI
+
+        The commit message captured is only the subject line (first line), not the full message.
+
+        Returns:
+            GitMetadata instance containing:
+            - commit_id: The git commit SHA, or None if unavailable
+            - commit_message: The commit subject line (first line only), or None if unavailable
+            - repository_url: The git repository URL, or None if unavailable
+        """
+        commit_id = None
+        commit_message = None
+        repository_url = None
+
+        # Try environment variables first (Jenkins Git plugin)
+        env_commit = os.environ.get("GIT_COMMIT")
+        env_url = os.environ.get("GIT_URL")
+
+        if env_commit:
+            commit_id = env_commit if env_commit.strip() else None
+        if env_url:
+            repository_url = env_url if env_url.strip() else None
+
+        # Fallback to git commands if environment variables not available
+        # Get commit ID
+        if not commit_id:
+            try:
+                result = SubprocessExecutor(["git", "rev-parse", "HEAD"]).execute(handle_errors=False)
+                if result and result.returncode == 0:
+                    value = result.stdout.strip()
+                    commit_id = value if value else None
+            except Exception as e:
+                logger.warning(f"Failed to get commit ID from git: {e}")
+
+        # Get commit message (subject line only)
+        if not commit_message:
+            try:
+                result = SubprocessExecutor(["git", "log", "-1", "--format=%s"]).execute(handle_errors=False)
+                if result and result.returncode == 0:
+                    value = result.stdout.strip()
+                    commit_message = value if value else None
+            except Exception as e:
+                logger.warning(f"Failed to get commit message from git: {e}")
+
+        # Get repository URL
+        if not repository_url:
+            try:
+                result = SubprocessExecutor(["git", "config", "--get", "remote.origin.url"]).execute(handle_errors=False)
+                if result and result.returncode == 0:
+                    value = result.stdout.strip()
+                    repository_url = value if value else None
+            except Exception as e:
+                logger.warning(f"Failed to get repository URL from git: {e}")
+
+        return GitMetadata(
+            commit_id=commit_id,
+            commit_message=commit_message,
+            repository_url=repository_url,
+        )
 
     def create_rt_upload_json(self, out_dir: Path) -> Path:
         """
@@ -299,10 +413,10 @@ class ArtifactsArchiver:
             Path to the created rt-upload.json file
         """
         # Get build metadata from environment or defaults
-        branch_name, build_number, is_tag = self._get_build_metadata()
+        metadata = self._get_build_metadata()
 
         # Calculate retention period based on branch/tag
-        retention_period = self.calculate_retention_period(branch_name, is_tag)
+        retention_period = self.calculate_retention_period(metadata.branch_name, metadata.is_tag)
 
         # Create the files array for Artifactory upload format
         files_array = []
@@ -312,7 +426,7 @@ class ArtifactsArchiver:
                 target_repo = self._target_repos[archive_name]
 
                 # Construct the RT target path
-                rt_target = f"{target_repo}/{branch_name}/{build_number}/"
+                rt_target = f"{target_repo}/{metadata.branch_name}/{metadata.build_number}/"
 
                 # Add this archive to the files array with retention_period property
                 files_array.append(
@@ -344,6 +458,17 @@ class ArtifactsArchiver:
         but no artifacts. Use update_artifacts_json() to add artifact categories.
         It uses Jenkins environment variables when available, otherwise falls back to default values.
 
+        The JSON file includes conditional keys based on the build type:
+        - For pull requests: includes "pull_request" key with the PR number (e.g., "117")
+        - For tag builds: includes "tag" key with the tag name (e.g., "v1.2.3")
+        - For regular branch builds: includes "branch" key with the branch name (e.g., "develop")
+
+        Optional fields (included only if available):
+        - build_url: Jenkins build URL from BUILD_URL environment variable
+        - commit_id: Git commit SHA from GIT_COMMIT env var or git rev-parse HEAD
+        - commit_message: Git commit subject line from git log (first line only)
+        - repository_url: Git repository URL from GIT_URL env var or git config
+
         Args:
             variant: The variant name (e.g., "Disco")
             out_dir: Directory where the artifacts.json file will be created
@@ -358,11 +483,43 @@ class ArtifactsArchiver:
         if not variant or not variant.strip():
             raise ValueError("Variant name cannot be empty or None")
 
-        # Get build metadata from environment or defaults
-        branch_name, build_number, _ = self._get_build_metadata()
+        # Get metadata from environment or defaults
+        build_metadata = self._get_build_metadata()
+        git_metadata = self._get_git_metadata()
+
+        # Create the initial artifacts.json structure with base metadata
+        artifacts_data: Dict[str, Any] = {
+            "variant": variant,
+            "build_timestamp": datetime.now(timezone.utc).isoformat(timespec="seconds") + "Z",
+            "build_number": build_metadata.build_number,
+        }
+
+        # Add build_url if available
+        build_url = os.environ.get("BUILD_URL")
+        if build_url:
+            artifacts_data["build_url"] = build_url
+
+        # Add conditional keys based on build type
+        if build_metadata.pr_number:
+            # Pull request build
+            artifacts_data["pull_request"] = build_metadata.pr_number
+        elif build_metadata.is_tag:
+            # Tag build
+            artifacts_data["tag"] = build_metadata.branch_name
+        else:
+            # Regular branch build (or local build)
+            artifacts_data["branch"] = build_metadata.branch_name
+
+        # Add git metadata if available
+        if git_metadata.commit_id:
+            artifacts_data["commit_id"] = git_metadata.commit_id
+        if git_metadata.commit_message:
+            artifacts_data["commit_message"] = git_metadata.commit_message
+        if git_metadata.repository_url:
+            artifacts_data["repository_url"] = git_metadata.repository_url
 
-        # Create the initial artifacts.json structure
-        artifacts_data = {"variant": variant, "build_timestamp": datetime.now(timezone.utc).isoformat(timespec="seconds") + "Z", "build_number": build_number, "branch_name": branch_name, "artifacts": {}}
+        # Add empty artifacts dictionary
+        artifacts_data["artifacts"] = {}
 
         # Create the artifacts.json file
         json_path = out_dir / "artifacts.json"
@@ -487,6 +644,10 @@ class ArtifactsArchiver:
 # out_dir = Path("./build/output")
 #
 # # Create initial artifacts.json file first, then add categories
+# # The resulting JSON will contain conditional keys based on build type:
+# # - For PRs: {"variant": "Disco", "build_timestamp": "...", "build_number": "123", "pull_request": "117", "artifacts": {}}
+# # - For tags: {"variant": "Disco", "build_timestamp": "...", "build_number": "123", "tag": "v1.2.3", "artifacts": {}}
+# # - For branches: {"variant": "Disco", "build_timestamp": "...", "build_number": "123", "branch": "develop", "artifacts": {}}
 # artifacts_json_path = archiver.create_artifacts_json(variant, out_dir)
 # archiver.update_artifacts_json("test_reports", test_reports, artifacts_json_path)
 # archiver.update_artifacts_json("sca_reports", sca_reports, artifacts_json_path)

spl_core-7.15.0rc1/src/spl_core/test_utils/junit_merger.py

@@ -0,0 +1,122 @@
+"""
+JUnit XML Merger
+
+Merges multiple JUnit XML files into a single variant-level JUnit XML file.
+This enables CI/CD tooling to consume aggregated test results from all components.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+
+from junitparser import JUnitXml
+
+
+class JUnitMergerError(Exception):
+    """Exception raised when JUnit XML merging fails."""
+
+    pass
+
+
+class JUnitMerger:
+    """
+    Merges multiple JUnit XML files into a single variant-level JUnit XML file.
+
+    This class provides functionality to aggregate test results from multiple
+    components into a unified JUnit XML file for CI/CD tooling.
+    """
+
+    def __init__(self, input_files: List[str], output_file: str):
+        """
+        Initialize the JUnit merger.
+
+        Args:
+            input_files: List of paths to input JUnit XML files
+            output_file: Path to output merged JUnit XML file
+
+        Raises:
+            ValueError: If input_files list is empty
+        """
+        if not input_files:
+            raise ValueError("No input files provided for merging")
+
+        self.input_files = input_files
+        self.output_file = output_file
+
+    def merge(self) -> None:
+        """
+        Merge all input JUnit XML files into the output file.
+
+        Raises:
+            FileNotFoundError: If any input file doesn't exist
+            Exception: If any input file contains malformed XML or validation fails
+        """
+        # Create merged JUnit XML container
+        merged_xml = JUnitXml()
+
+        # Process each input file
+        for input_path in self.input_files:
+            input_file = Path(input_path)
+
+            if not input_file.exists():
+                raise FileNotFoundError(f"Input file not found: {input_path}")
+
+            try:
+                # Parse the input JUnit XML file
+                xml = JUnitXml.fromfile(str(input_file))
+
+                # Add all test suites from this file to the merged result
+                for suite in xml:
+                    merged_xml.add_testsuite(suite)
+
+            except Exception as e:
+                raise JUnitMergerError(f"Failed to parse JUnit XML file '{input_path}': {e}") from e
+
+        # Write merged result to output file
+        output_path = Path(self.output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        merged_xml.write(str(output_path))
+
+        # Validate the output
+        self._validate_output()
+
+    def _validate_output(self) -> None:
+        """
+        Validate that the merged output file is valid JUnit XML.
+
+        Raises:
+            Exception: If the output file cannot be parsed as valid JUnit XML
+        """
+        try:
+            JUnitXml.fromfile(str(self.output_file))
+        except Exception as e:
+            raise JUnitMergerError(f"Validation failed: merged output is not valid JUnit XML: {e}") from e
+
+
+def main() -> int:
+    """
+    Main entry point for command-line interface.
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    parser = argparse.ArgumentParser(description="Merge multiple JUnit XML files into a single variant-level file")
+    parser.add_argument("--output", required=True, help="Path to output merged JUnit XML file")
+    parser.add_argument("--inputs", nargs="+", required=True, help="Paths to input JUnit XML files to merge")
+
+    args = parser.parse_args()
+
+    try:
+        merger = JUnitMerger(args.inputs, args.output)
+        merger.merge()
+        print(f"Successfully merged {len(args.inputs)} JUnit XML file(s) into {args.output}")
+        return 0
+
+    except Exception as e:
+        print(f"ERROR: Failed to merge JUnit XML files: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

spl_core-7.14.0rc4.dev3/src/spl_core/__init__.py

@@ -1 +0,0 @@
-__version__ = "7.14.0-rc4.dev.3"