infrahub-server 1.1.5__py3-none-any.whl → 1.1.7__py3-none-any.whl

infrahub_testcontainers/helpers.py

@@ -1,4 +1,5 @@
 import os
+import shutil
 import subprocess  # noqa: S404
 from pathlib import Path
 
@@ -36,12 +37,25 @@ class TestInfrahubDocker:
 
         return directory
 
+    @pytest.fixture(scope="class")
+    def remote_backups_dir(self, tmp_directory: Path) -> Path:
+        directory = tmp_directory / PROJECT_ENV_VARIABLES["INFRAHUB_TESTING_LOCAL_DB_BACKUP_DIRECTORY"]
+        directory.mkdir(exist_ok=True)
+
+        return directory
+
     @pytest.fixture(scope="class")
     def default_branch(self) -> str:
         return "main"
 
     @pytest.fixture(scope="class")
-    def infrahub_compose(self, tmp_directory: Path, infrahub_version: str) -> InfrahubDockerCompose:
+    def infrahub_compose(
+        self,
+        tmp_directory: Path,
+        remote_repos_dir: Path,  # initialize repository before running docker compose to fix permissions issues # noqa: ARG002
+        remote_backups_dir: Path,  # noqa: ARG002
+        infrahub_version: str,
+    ) -> InfrahubDockerCompose:
         return InfrahubDockerCompose.init(directory=tmp_directory, version=infrahub_version)
 
     @pytest.fixture(scope="class")
@@ -62,3 +76,73 @@ class TestInfrahubDocker:
     @pytest.fixture(scope="class")
     def task_manager_port(self, infrahub_app: dict[str, int]) -> int:
         return infrahub_app["task-manager"]
+
+    def backup_database(self, request: pytest.FixtureRequest, dest_dir: Path | None = None) -> None:
+        assert "enterprise" in os.environ.get("NEO4J_DOCKER_IMAGE", "")
+
+        backup_dir: Path = request.getfixturevalue("remote_backups_dir")
+        infrahub_compose: InfrahubDockerCompose = request.getfixturevalue("infrahub_compose")
+
+        infrahub_compose.exec_in_container(
+            command=[
+                "neo4j-admin",
+                "database",
+                "backup",
+                "--to-path",
+                os.environ.get(
+                    "INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY",
+                    PROJECT_ENV_VARIABLES["INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY"],
+                ),
+            ],
+            service_name="database",
+        )
+
+        if dest_dir:
+            shutil.copytree(
+                str(backup_dir),
+                str(dest_dir),
+            )
+
+    def restore_database(self, request: pytest.FixtureRequest, backup_file: Path) -> None:
+        assert "enterprise" in os.environ.get("NEO4J_DOCKER_IMAGE", "")
+
+        backup_dir: Path = request.getfixturevalue("remote_backups_dir")
+        infrahub_compose: InfrahubDockerCompose = request.getfixturevalue("infrahub_compose")
+
+        shutil.copy(
+            str(backup_file),
+            str(backup_dir / backup_file.name),
+        )
+
+        infrahub_compose.exec_in_container(
+            command=["cypher-shell", "-u", "neo4j", "-p", "admin", "STOP DATABASE neo4j;"],
+            service_name="database",
+        )
+
+        infrahub_compose.exec_in_container(
+            command=[
+                "neo4j-admin",
+                "database",
+                "restore",
+                "--overwrite-destination",
+                "--from-path",
+                str(
+                    Path(
+                        os.environ.get(
+                            "INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY",
+                            PROJECT_ENV_VARIABLES["INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY"],
+                        )
+                    )
+                    / backup_file.name
+                ),
+            ],
+            service_name="database",
+        )
+
+        infrahub_compose.exec_in_container(
+            command=["cypher-shell", "-d", "system", "-u", "neo4j", "-p", "admin", "START DATABASE neo4j;"],
+            service_name="database",
+        )
+
+        infrahub_compose.stop(down=False)
+        infrahub_compose.start()

infrahub/core/diff/enricher/summary_counts.py

@@ -1,105 +0,0 @@
-from collections import Counter
-from typing import Iterable
-
-from infrahub.core.constants import DiffAction
-
-from ..model.path import (
-    BaseSummary,
-    CalculatedDiffs,
-    EnrichedDiffAttribute,
-    EnrichedDiffNode,
-    EnrichedDiffRelationship,
-    EnrichedDiffRoot,
-    EnrichedDiffSingleRelationship,
-)
-from .interface import DiffEnricherInterface
-
-
-class DiffSummaryCountsEnricher(DiffEnricherInterface):
-    async def enrich(
-        self, enriched_diff_root: EnrichedDiffRoot, calculated_diffs: CalculatedDiffs | None = None
-    ) -> None:
-        self._add_root_summaries(diff_root=enriched_diff_root)
-
-    def _add_summary(self, summary_node: BaseSummary, actions: Iterable[DiffAction]) -> None:
-        summary_count = Counter(actions)
-        summary_node.num_added = summary_count.get(DiffAction.ADDED, 0)
-        summary_node.num_updated = summary_count.get(DiffAction.UPDATED, 0)
-        summary_node.num_removed = summary_count.get(DiffAction.REMOVED, 0)
-
-    def _add_root_summaries(self, diff_root: EnrichedDiffRoot) -> None:
-        contains_conflict = False
-        num_conflicts = 0
-        for diff_node in diff_root.nodes:
-            contains_conflict |= self._add_node_summaries(diff_node=diff_node)
-            if diff_node.conflict or diff_node.contains_conflict:
-                num_conflicts += 1
-        self._add_summary(summary_node=diff_root, actions=(n.action for n in diff_root.nodes))
-        diff_root.contains_conflict = contains_conflict
-        diff_root.num_conflicts = num_conflicts
-        self._add_child_nodes_to_summaries(diff_root=diff_root)
-
-    def _add_node_summaries(self, diff_node: EnrichedDiffNode) -> bool:
-        contains_conflict = False
-        num_conflicts = 0
-        for diff_attr in diff_node.attributes:
-            contains_conflict |= self._add_attribute_summaries(diff_attribute=diff_attr)
-            if diff_attr.contains_conflict:
-                num_conflicts += 1
-        for diff_rel in diff_node.relationships:
-            contains_conflict |= self._add_relationship_summaries(diff_relationship=diff_rel)
-            if diff_rel.contains_conflict:
-                num_conflicts += 1
-        self._add_summary(
-            summary_node=diff_node, actions=(field.action for field in diff_node.relationships | diff_node.attributes)
-        )
-        diff_node.contains_conflict = contains_conflict
-        diff_node.num_conflicts = num_conflicts
-        return contains_conflict
-
-    def _add_attribute_summaries(self, diff_attribute: EnrichedDiffAttribute) -> bool:
-        contains_conflict = False
-        num_conflicts = 0
-        for diff_prop in diff_attribute.properties:
-            if diff_prop.conflict:
-                num_conflicts += 1
-                contains_conflict = True
-        self._add_summary(summary_node=diff_attribute, actions=(p.action for p in diff_attribute.properties))
-        diff_attribute.contains_conflict = contains_conflict
-        diff_attribute.num_conflicts = num_conflicts
-        return contains_conflict
-
-    def _add_relationship_summaries(self, diff_relationship: EnrichedDiffRelationship) -> bool:
-        contains_conflict = False
-        num_conflicts = 0
-        for diff_element in diff_relationship.relationships:
-            contains_conflict |= self._add_element_summaries(diff_element=diff_element)
-            if diff_element.conflict:
-                num_conflicts += 1
-        self._add_summary(summary_node=diff_relationship, actions=(e.action for e in diff_relationship.relationships))
-        diff_relationship.contains_conflict = contains_conflict
-        diff_relationship.num_conflicts = num_conflicts
-        return contains_conflict
-
-    def _add_element_summaries(self, diff_element: EnrichedDiffSingleRelationship) -> bool:
-        if diff_element.conflict is None:
-            contains_conflict = False
-            num_conflicts = 0
-        else:
-            contains_conflict = True
-            num_conflicts = 1
-        for diff_prop in diff_element.properties:
-            if diff_prop.conflict:
-                num_conflicts += 1
-                contains_conflict = True
-        self._add_summary(summary_node=diff_element, actions=(p.action for p in diff_element.properties))
-        diff_element.contains_conflict = contains_conflict
-        diff_element.num_conflicts = num_conflicts
-        return contains_conflict
-
-    def _add_child_nodes_to_summaries(self, diff_root: EnrichedDiffRoot) -> None:
-        for diff_node in diff_root.nodes:
-            for diff_rel in diff_node.relationships:
-                if not diff_rel.contains_conflict:
-                    diff_rel.contains_conflict = any(n.contains_conflict for n in diff_rel.nodes)
-                diff_rel.num_conflicts += sum(bool(n.contains_conflict or n.conflict) for n in diff_rel.nodes)

infrahub/dependencies/builder/diff/enricher/summary_counts.py

@@ -1,8 +0,0 @@
-from infrahub.core.diff.enricher.summary_counts import DiffSummaryCountsEnricher
-from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
-
-
-class DiffSummaryCountsEnricherDependency(DependencyBuilder[DiffSummaryCountsEnricher]):
-    @classmethod
-    def build(cls, context: DependencyBuilderContext) -> DiffSummaryCountsEnricher:
-        return DiffSummaryCountsEnricher()