spl-core 4.1.0__tar.gz → 4.1.2__tar.gz

{spl_core-4.1.0 → spl_core-4.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spl-core
-Version: 4.1.0
+Version: 4.1.2
 Summary: Software Product Line Support for CMake
 Home-page: https://github.com/avengineers/spl-core
 License: MIT

{spl_core-4.1.0 → spl_core-4.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "spl-core"
-version = "4.1.0"
+version = "4.1.2"
 description = "Software Product Line Support for CMake"
 authors = ["Avengineers <karsten.guenther@kamg.de>"]
 license = "MIT"

spl_core-4.1.2/src/spl_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "4.1.2"

{spl_core-4.1.0 → spl_core-4.1.2}/src/spl_core/test_utils/base_variant_test_runner.py

@@ -27,7 +27,7 @@ class BaseVariantTestRunner(ABC):
 
     @property
     def expected_variant_report_artifacts(self) -> List[Path]:
-        return [Path("reports/reports/index.html")]
+        return [Path("reports/html/index.html")]
 
     @property
     def expected_component_report_artifacts(self) -> List[Path]:
@@ -39,23 +39,46 @@ class BaseVariantTestRunner(ABC):
             Path("coverage/index.html"),
         ]
 
+    @property
+    def create_artifacts_archive(self) -> bool:
+        return True
+
+    @property
+    def create_artifacts_json(self) -> bool:
+        return True
+
+    @property
+    def expected_archive_artifacts(self) -> List[Path]:
+        return self.expected_build_artifacts
+
+    def assert_artifact_exists(self, dir: Path, artifact: Path) -> None:
+        if artifact.is_absolute():
+            assert artifact.exists(), f"Artifact {artifact} does not exist"  # noqa: S101
+        else:
+            assert Path.joinpath(dir, artifact).exists(), f"Artifact {Path.joinpath(dir, artifact)} does not exist"  # noqa: S101
+
     def test_build(self) -> None:
         spl_build: SplBuild = SplBuild(variant=self.variant, build_kit="prod")
         assert 0 == spl_build.execute(target="all")  # noqa: S101
         for artifact in self.expected_build_artifacts:
-            assert artifact.exists() or Path.joinpath(spl_build.build_dir, artifact).exists()  # noqa: S101
+            self.assert_artifact_exists(dir=spl_build.build_dir, artifact=artifact)
+        if self.create_artifacts_archive:
+            # create artifacts archive
+            spl_build.create_artifacts_archive(self.expected_archive_artifacts)
+        if self.create_artifacts_json:
+            spl_build.create_artifacts_json(self.expected_archive_artifacts)
 
     def test_unittest(self) -> None:
         spl_build: SplBuild = SplBuild(variant=self.variant, build_kit="test")
         assert 0 == spl_build.execute(target="unittests")  # noqa: S101
         for artifact in self.expected_test_artifacts:
-            assert artifact.exists()  # noqa: S101
+            self.assert_artifact_exists(dir=spl_build.build_dir, artifact=artifact)
 
     def test_reports(self) -> None:
         spl_build: SplBuild = SplBuild(variant=self.variant, build_kit="test")
         assert 0 == spl_build.execute(target="all")  # noqa: S101
         for artifact in self.expected_variant_report_artifacts:
-            assert Path.joinpath(spl_build.build_dir, artifact).exists()  # noqa: S101
+            self.assert_artifact_exists(dir=spl_build.build_dir, artifact=artifact)
         for component in self.component_paths:
             for artifact in self.expected_component_report_artifacts:
-                assert Path.joinpath(spl_build.build_dir, component, artifact).exists()  # noqa: S101
+                self.assert_artifact_exists(dir=Path.joinpath(spl_build.build_dir, "reports", "html", spl_build.build_dir, component, "reports"), artifact=artifact)

spl_core-4.1.2/src/spl_core/test_utils/spl_build.py

@@ -0,0 +1,162 @@
+import json
+import time
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+from py_app_dev.core.logging import time_it
+
+from spl_core.common.command_line_executor import CommandLineExecutor
+
+
+@dataclass
+class ArchiveArtifact:
+    archive_path: Path
+    absolute_path: Path
+
+
+class ArtifactsCollection:
+    def __init__(self, artifacts: List[Path], build_dir: Path):
+        self.archive_artifacts: List[ArchiveArtifact] = []
+        for artifact in artifacts:
+            if artifact.is_absolute():
+                artifact_path = artifact
+            else:
+                artifact_path = Path.joinpath(build_dir.absolute(), artifact)
+            if artifact_path.is_dir():
+                for artifact in artifact_path.glob("**/*"):
+                    if artifact.is_file():
+                        if artifact_path.is_relative_to(build_dir.absolute()):
+                            self.archive_artifacts.append(ArchiveArtifact(archive_path=artifact.relative_to(build_dir.absolute()), absolute_path=artifact.absolute()))
+                        else:
+                            self.archive_artifacts.append(ArchiveArtifact(archive_path=Path(artifact.name), absolute_path=artifact.absolute()))
+            else:
+                if artifact_path.is_relative_to(build_dir.absolute()):
+                    self.archive_artifacts.append(ArchiveArtifact(archive_path=artifact_path.relative_to(build_dir.absolute()), absolute_path=artifact_path.absolute()))
+                else:
+                    self.archive_artifacts.append(ArchiveArtifact(archive_path=Path(artifact_path.name), absolute_path=artifact_path.absolute()))
+
+
+class SplBuild:
+    """Class for building an SPL repository."""
+
+    def __init__(self, variant: str, build_kit: str):
+        """
+        Initialize a SplBuild instance.
+
+        Args:
+            variant (str): The build variant.
+            build_kit (str): The build kit.
+
+        """
+        self.variant = variant
+        self.build_kit = build_kit
+
+    @property
+    def build_dir(self) -> Path:
+        """
+        Get the build directory.
+
+        Returns:
+            Path: The build directory path.
+
+        """
+        return Path(f"build/{self.variant}/{self.build_kit}")
+
+    @time_it()
+    def execute(self, target: str, additional_args: Optional[List[str]] = None) -> int:
+        """
+        Build the target
+
+        Args:
+            target (str): The build target.
+            additional_args (List[str], optional): Additional arguments for building. Defaults to ["-build"].
+
+        Returns:
+            int: 0 in case of success.
+
+        """
+        if additional_args is None:
+            additional_args = ["-build"]
+        return_code = -1
+        while True:
+            cmd = [
+                "build.bat",
+                "-buildKit",
+                self.build_kit,
+                "-variants",
+                self.variant,
+                "-target",
+                target,
+                "-reconfigure",
+            ]
+            cmd.extend(additional_args)
+            result = CommandLineExecutor().execute(cmd)
+            return_code = result.returncode
+            if result.returncode:
+                if result.stdout:
+                    if any(error in str(result.stdout) for error in ["No valid floating license", "No valid license", "GHS_LMHOST = N/A"]):
+                        print("Probably a license issue, retrying ...")
+                        time.sleep(10)
+                    else:
+                        break
+                else:
+                    break
+            else:
+                break
+        return return_code
+
+    def create_artifacts_archive(self, expected_artifacts: List[Path]) -> Path:
+        """
+        Create a zip file containing the collected artifacts.
+
+        Args:
+            expected_artifacts: List of Path of artifacts which should be archived
+
+        Returns:
+            Path: The path to the created zip file.
+
+        Raises:
+            Exception: If there is an error creating the zip file.
+
+        """
+        zip_path = self.build_dir / "artifacts.zip"
+
+        # Delete the file if it already exists
+        if zip_path.exists():
+            zip_path.unlink()
+
+        try:
+            with zipfile.ZipFile(zip_path, "w") as zip_file:
+                artifacts_collection = ArtifactsCollection(artifacts=expected_artifacts, build_dir=self.build_dir)
+                for artifact in artifacts_collection.archive_artifacts:
+                    zip_file.write(artifact.absolute_path, arcname=artifact.archive_path)
+            print(f"Zip file created at: {zip_path}")
+            return zip_path
+        except Exception as e:
+            print(f"Error creating artifacts zip file: {e}")
+            raise e
+
+    def create_artifacts_json(self, expected_artifacts: List[Path]) -> Path:
+        """
+        Create a JSON file listing the collected artifacts.
+
+        Returns:
+            Path: The path to the created JSON file.
+
+        Raises:
+            Exception: If there is an error creating the JSON file.
+
+        """
+        artifacts_collection = ArtifactsCollection(artifacts=expected_artifacts, build_dir=self.build_dir)
+        json_content = {
+            "variant": self.variant,
+            "build_kit": self.build_kit,
+            "artifacts": [str(artifact.archive_path.as_posix()) for artifact in artifacts_collection.archive_artifacts],
+        }
+        json_path = self.build_dir / "artifacts.json"
+
+        json_path.write_text(json.dumps(json_content, indent=4))
+
+        return json_path

spl_core-4.1.0/src/spl_core/__init__.py

@@ -1 +0,0 @@
-__version__ = "4.1.0"

spl_core-4.1.0/src/spl_core/test_utils/spl_build.py

@@ -1,77 +0,0 @@
-import time
-from pathlib import Path
-from typing import List, Optional
-
-from py_app_dev.core.logging import time_it
-
-from spl_core.common.command_line_executor import CommandLineExecutor
-
-
-class SplBuild:
-    """Class for building an SPL repository."""
-
-    def __init__(self, variant: str, build_kit: str):
-        """
-        Initialize a SplBuild instance.
-
-        Args:
-            variant (str): The build variant.
-            build_kit (str): The build kit.
-
-        """
-        self.variant = variant
-        self.build_kit = build_kit
-
-    @property
-    def build_dir(self) -> Path:
-        """
-        Get the build directory.
-
-        Returns:
-            Path: The build directory path.
-
-        """
-        return Path(f"build/{self.variant}/{self.build_kit}")
-
-    @time_it()
-    def execute(self, target: str, additional_args: Optional[List[str]] = None) -> int:
-        """
-        Build the target
-
-        Args:
-            target (str): The build target.
-            additional_args (List[str], optional): Additional arguments for building. Defaults to ["-build"].
-
-        Returns:
-            int: 0 in case of success.
-
-        """
-        if additional_args is None:
-            additional_args = ["-build"]
-        return_code = -1
-        while True:
-            cmd = [
-                "build.bat",
-                "-buildKit",
-                self.build_kit,
-                "-variants",
-                self.variant,
-                "-target",
-                target,
-                "-reconfigure",
-            ]
-            cmd.extend(additional_args)
-            result = CommandLineExecutor().execute(cmd)
-            return_code = result.returncode
-            if result.returncode:
-                if result.stdout:
-                    if any(error in str(result.stdout) for error in ["No valid floating license", "No valid license", "GHS_LMHOST = N/A"]):
-                        print("Probably a license issue, retrying ...")
-                        time.sleep(10)
-                    else:
-                        break
-                else:
-                    break
-            else:
-                break
-        return return_code