test: add tests (and fix some bugs)

Author: abraemer

src/opossum_lib/core/services/extract_subtree_impl.py

@@ -53,6 +53,7 @@ def _extract_scan_results(opossum: Opossum, subpath: PurePosixPath) -> ScanResul
     kept_attributions = set()
     for resource in new_root_resource.all_resources():
         kept_attributions |= set(resource.attributions)
+    kept_attributions |= opossum.scan_results.unassigned_attributions
     new_attribution_to_id = {
         attribution: id
         for (attribution, id) in opossum.scan_results.attribution_to_id.items()
@@ -86,28 +87,32 @@ def _filter_review_results(
         update={"input_file_md5_checksum": None}
     )
 
+    # the paths used as keys for manual_attributions include a leading "/"
     absolute_subpath = "/" / subpath
-    # the paths used as keys for  manual_attributions include a leading "/"
-    new_manual_attributions = {
-        path: attributions
-        for (path, attributions) in old_review_results.manual_attributions.items()
-        if PurePosixPath(path).is_relative_to(absolute_subpath)
-    }
     new_resources_to_attributions = {
         path: attributions
         for (path, attributions) in old_review_results.resources_to_attributions.items()
         if PurePosixPath(path).is_relative_to(absolute_subpath)
     }
 
+    new_manual_attribution_ids = {
+        id for ids in new_resources_to_attributions.values() for id in ids
+    }
+    new_manual_attributions = {
+        id: attributions
+        for (id, attributions) in old_review_results.manual_attributions.items()
+        if id in new_manual_attribution_ids
+    }
+
     # since we loaded an Opossum file, every resource has a preexisting ID and thus
     # new_scan_results.attribution_to_id contains the ID of each resource
     # in new_scan_results
+    all_external_attribution_ids = set(new_scan_results.attribution_to_id.values())
     if old_review_results.resolved_external_attributions:
-        all_attributions = set(new_scan_results.attribution_to_id.values())
         new_resolved_external_attributions = [
             attributionID
             for attributionID in old_review_results.resolved_external_attributions
-            if attributionID in all_attributions
+            if attributionID in all_external_attribution_ids
         ]
     else:
         new_resolved_external_attributions = None

tests/core/entities/generators/opossum_provider.py

@@ -34,7 +34,9 @@ def opossum(
         if generate_review_results is None:
             generate_review_results = bool(self.random_int(max=1))
         if generate_review_results and not review_results:
-            review_results = self.review_result_provider.output_file()
+            review_results = self.review_result_provider.output_file(
+                scan_results=scan_results
+            )
         return Opossum(
             scan_results=scan_results,
             review_results=review_results,

tests/input_formats/opossum/entities/generators/generate_outfile_information.py

@@ -12,9 +12,9 @@
 from faker.providers.misc import Provider as MiscProvider
 from faker.providers.person import Provider as PersonProvider
 
+from opossum_lib.core.entities.scan_results import ScanResults
 from opossum_lib.shared.entities.opossum_input_file_model import (
     OpossumPackageIdentifierModel,
-    OpossumPackageModel,
     ResourceInFileModel,
 )
 from opossum_lib.shared.entities.opossum_output_file_model import (
@@ -52,16 +52,36 @@ def output_file(
         manual_attributions: dict[str, ManualAttributions] | None = None,
         resources_to_attributions: dict[str, list[str]] | None = None,
         resolved_external_attributions: list[str] | None = None,
+        scan_results: ScanResults | None = None,
     ) -> OpossumOutputFileModel:
         if metadata is None:
-            metadata = self.outfile_metadata()
+            project_id = scan_results.metadata.project_id if scan_results else None
+            file_creation_date = (
+                scan_results.metadata.file_creation_date if scan_results else None
+            )
+            metadata = self.outfile_metadata(
+                project_id=project_id,
+                file_creation_date=file_creation_date,
+            )
         if manual_attributions is None:
             manual_attributions = self.manual_attributions()
         if resolved_external_attributions is None:
-            resolved_external_attributions = self.resolved_external_attributions()
+            external_attributions_ids = (
+                list(scan_results.attribution_to_id.values()) if scan_results else None
+            )
+            resolved_external_attributions = self.resolved_external_attributions(
+                external_attributions_ids=external_attributions_ids
+            )
         if resources_to_attributions is None:
+            all_paths = None
+            if scan_results:
+                all_paths = [
+                    str(resource.path)
+                    for resource in scan_results.resources.all_resources()
+                ]
             resources_to_attributions = self.resources_to_attributions(
-                manual_attributions=manual_attributions
+                manual_attributions=manual_attributions,
+                all_paths=all_paths,
             )
         return OpossumOutputFileModel(
             metadata=metadata,
@@ -185,32 +205,54 @@ def manual_attribution(
     def resolved_external_attributions(
         self,
         *,
-        external_attributions: dict[OpossumPackageIdentifierModel, OpossumPackageModel]
-        | None = None,
+        external_attributions_ids: list[OpossumPackageIdentifierModel] | None = None,
         min_count: int = 1,
         max_count: int = 5,
     ) -> list[str]:
         length = self.random_int(min=min_count, max=max_count)
-        if external_attributions is not None:
-            length = min(length, len(external_attributions))
-            ids = list(external_attributions.keys())
-            return list(self.random_elements(elements=ids, length=length, unique=True))
+        if external_attributions_ids is not None:
+            length = min(length, len(external_attributions_ids))
+            return list(
+                self.random_elements(
+                    external_attributions_ids, length=length, unique=True
+                )
+            )
         else:
             return [str(self.misc_provider.uuid4()) for _ in range(length)]
 
+    def _resources_to_path(
+        self,
+        resources: ResourceInFileModel,
+    ) -> list[str]:
+        paths: list[str] = []
+        if isinstance(resources, int):
+            return paths
+        for path_segment, children in resources.items():
+            if isinstance(children, int):
+                paths.append(path_segment)
+            else:
+                subpaths = self._resources_to_path(children)
+                paths.extend(path_segment + "/" + subpath for subpath in subpaths)
+        return paths
+
+    def _ensure_root_prefix(self, path: str) -> str:
+        if not path.startswith("/"):
+            return "/" + path
+        else:
+            return path
+
     def resources_to_attributions(
         self,
         *,
         resources: ResourceInFileModel | None = None,
         manual_attributions: dict[str, ManualAttributions] | None = None,
+        all_paths: list[str] | None,
         min_count: int = 1,
         max_count: int = 5,
         num_attributions: int = 3,
     ) -> dict[str, list[str]]:
         if manual_attributions is None:
             manual_attributions = self.manual_attributions()
-        if resources is None:
-            resources = self.file_information_provider.resource_in_file()
         if manual_attributions is not None:
             attribution_ids = list(manual_attributions.keys())
         else:
@@ -219,21 +261,14 @@ def resources_to_attributions(
                 for _ in range(self.random_int(max=max_count * num_attributions))
             ]
 
-        def resources_to_path(
-            resources: ResourceInFileModel,
-        ) -> list[str]:
-            paths: list[str] = []
-            if isinstance(resources, int):
-                return paths
-            for path_segment, children in resources.items():
-                if isinstance(children, int):
-                    paths.append(path_segment)
-                else:
-                    subpaths = resources_to_path(children)
-                    paths.extend(path_segment + "/" + subpath for subpath in subpaths)
-            return paths
+        all_paths = all_paths or []
+        if resources:
+            all_paths.extend(self._resources_to_path(resources))
+        if not all_paths:
+            resources = self.file_information_provider.resource_in_file()
+            all_paths.extend(self._resources_to_path(resources))
+        all_paths = [self._ensure_root_prefix(path) for path in all_paths]
 
-        all_paths = ["/" + path for path in resources_to_path(resources)]
         number_of_paths = min(
             self.random_int(min=min_count, max=max_count), len(all_paths)
         )

tests/setup/opossum_faker_setup.py

@@ -40,6 +40,7 @@ def __init__(self) -> None:
         self.output_file = review_result_provider.output_file
         self.outfile_metadata = review_result_provider.outfile_metadata
         self.manual_attributions = review_result_provider.manual_attributions
+        self.manual_attribution = review_result_provider.manual_attribution
         self.resources_to_attributions = (
             review_result_provider.resources_to_attributions
         )

tests/test_cli.py

@@ -12,7 +12,7 @@
 from _pytest.logging import LogCaptureFixture
 from click.testing import CliRunner, Result
 
-from opossum_lib.cli import generate
+from opossum_lib.cli import extract_subtree, generate
 from opossum_lib.core.services.write_opossum_file import write_opossum_file
 from opossum_lib.shared.constants import (
     INPUT_JSON_NAME,
@@ -208,3 +208,50 @@ def test_convert(self, tmp_path: Path) -> None:
         )
 
         assert result.exit_code == 0
+
+
+class TestExtractSubtree:
+    def _run_extraction(
+        self,
+        tmp_path: Path,
+        subpath: str,
+        opossumfile: str = "opossum_input.opossum",
+        outputfile: str = "output.opossum",
+    ) -> Result:
+        runner = CliRunner()
+        cmd_line_arguments = [
+            str(test_data_path / opossumfile),
+            subpath,
+            "-o",
+            str(tmp_path / outputfile),
+        ]
+        result = runner.invoke(extract_subtree, cmd_line_arguments)
+        return result
+
+    def test_successful_extraction(self, tmp_path: Path) -> None:
+        result = self._run_extraction(tmp_path, "Frontend/Components")
+        assert result.exit_code == 0
+
+    def test_equivalency_of_subpaths(self, tmp_path: Path) -> None:
+        result1 = self._run_extraction(
+            tmp_path, "Frontend/Components", outputfile="out_basic"
+        )
+        result2 = self._run_extraction(
+            tmp_path, "/Frontend/Components", outputfile="out_root"
+        )
+        result3 = self._run_extraction(
+            tmp_path, "Frontend/Components/", outputfile="out_trailing"
+        )
+
+        assert result1.exit_code == 0
+        assert result2.exit_code == 0
+        assert result3.exit_code == 0
+
+        with open(tmp_path / "out_basic.opossum", "rb") as inp:
+            file_contents1 = inp.read()
+        with open(tmp_path / "out_root.opossum", "rb") as inp:
+            file_contents2 = inp.read()
+        with open(tmp_path / "out_trailing.opossum", "rb") as inp:
+            file_contents3 = inp.read()
+
+        assert file_contents1 == file_contents2 == file_contents3