infrahub-server 1.2.11__py3-none-any.whl → 1.2.12__py3-none-any.whl

infrahub_testcontainers/docker-compose.test.yml

@@ -59,6 +59,7 @@ services:
       NEO4J_ACCEPT_LICENSE_AGREEMENT: "yes"
       NEO4J_server_memory_heap_initial__size: ${INFRAHUB_TESTING_DB_HEAP_INITIAL_SIZE}
       NEO4J_server_memory_heap_max__size: ${INFRAHUB_TESTING_DB_HEAP_MAX_SIZE}
+      NEO4J_server_memory_pagecache_size: ${INFRAHUB_TESTING_DB_PAGECACHE_SIZE}
     volumes:
       - "database_data:/data"
       - "database_logs:/logs"

infrahub_testcontainers/helpers.py

@@ -1,5 +1,6 @@
 import os
 import subprocess  # noqa: S404
+import warnings
 from pathlib import Path
 
 import pytest
@@ -59,6 +60,10 @@ class TestInfrahubDocker:
     def default_branch(self) -> str:
         return "main"
 
+    @pytest.fixture(scope="class")
+    def deployment_type(self, request: pytest.FixtureRequest) -> str | None:
+        return request.config.getoption(name="infrahub_deployment_type", default=None)
+
     @pytest.fixture(scope="class")
     def infrahub_compose(
         self,
@@ -66,12 +71,21 @@ class TestInfrahubDocker:
         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,
+        deployment_type: str | None,
     ) -> InfrahubDockerCompose:
-        return InfrahubDockerCompose.init(directory=tmp_directory, version=infrahub_version)
+        return InfrahubDockerCompose.init(
+            directory=tmp_directory, version=infrahub_version, deployment_type=deployment_type
+        )
 
     @pytest.fixture(scope="class")
     def infrahub_app(self, request: pytest.FixtureRequest, infrahub_compose: InfrahubDockerCompose) -> dict[str, int]:
+        tests_failed_before_class = request.session.testsfailed
+
         def cleanup() -> None:
+            tests_failed_during_class = request.session.testsfailed - tests_failed_before_class
+            if tests_failed_during_class > 0:
+                stdout, stderr = infrahub_compose.get_logs("infrahub-server", "task-worker")
+                warnings.warn(f"Container logs:\nStdout:\n{stdout}\nStderr:\n{stderr}", stacklevel=2)
             infrahub_compose.stop()
 
         request.addfinalizer(cleanup)

infrahub_testcontainers/plugin.py

@@ -13,6 +13,15 @@ if TYPE_CHECKING:
 def pytest_addoption(parser: pytest.Parser) -> None:
     group = parser.getgroup("infrahub-performance-test")
 
+    group.addoption(
+        "--deployment-type",
+        action="store",
+        dest="infrahub_deployment_type",
+        default=None,
+        metavar="INFRAHUB_DEPLOYMENT_TYPE",
+        help="Type of deployment to use (default: None, options: cluster)",
+    )
+
     group.addoption(
         "--performance-result-address",
         action="store",

infrahub/patch/queries/consolidate_duplicated_nodes.py

@@ -1,109 +0,0 @@
-from ..models import EdgeToAdd, EdgeToDelete, PatchPlan, VertexToDelete
-from .base import PatchQuery
-
-
-class ConsolidateDuplicatedNodesPatchQuery(PatchQuery):
-    """
-    Find any groups of nodes with the same labels and properties, move all the edges to one of the duplicated nodes,
-    then delete the other duplicated nodes
-    """
-
-    @property
-    def name(self) -> str:
-        return "consolidate-duplicated-nodes"
-
-    async def plan(self) -> PatchPlan:
-        query = """
-//------------
-// Find nodes with the same labels and UUID
-//------------
-MATCH (n:Node)
-WITH n.uuid AS node_uuid, count(*) as num_nodes_with_uuid
-WHERE num_nodes_with_uuid > 1
-WITH DISTINCT node_uuid
-MATCH (n:Node {uuid: node_uuid})
-CALL {
-    WITH n
-    WITH labels(n) AS n_labels
-    UNWIND n_labels AS n_label
-    WITH n_label
-    ORDER BY n_label ASC
-    RETURN collect(n_label) AS sorted_labels
-}
-WITH n.uuid AS n_uuid, sorted_labels, collect(n) AS duplicate_nodes
-WHERE size(duplicate_nodes) > 1
-WITH n_uuid, head(duplicate_nodes) AS node_to_keep, tail(duplicate_nodes) AS nodes_to_delete
-UNWIND nodes_to_delete AS node_to_delete
-//------------
-// Find the edges that we need to move to the selected node_to_keep
-//------------
-CALL {
-    WITH node_to_keep, node_to_delete
-    MATCH (node_to_delete)-[edge_to_delete]->(peer)
-    RETURN {
-        from_id: %(id_func_name)s(node_to_keep),
-        to_id: %(id_func_name)s(peer),
-        edge_type: type(edge_to_delete),
-        after_props: properties(edge_to_delete)
-    } AS edge_to_create
-    UNION
-    WITH node_to_keep, node_to_delete
-    MATCH (node_to_delete)<-[edge_to_delete]-(peer)
-    RETURN {
-        from_id: %(id_func_name)s(peer),
-        to_id: %(id_func_name)s(node_to_keep),
-        edge_type: type(edge_to_delete),
-        after_props: properties(edge_to_delete)
-    } AS edge_to_create
-}
-WITH node_to_delete, collect(edge_to_create) AS edges_to_create
-//------------
-// Find the edges that we need to remove from the duplicated nodes
-//------------
-CALL {
-    WITH node_to_delete
-    MATCH (node_to_delete)-[e]->(peer)
-    RETURN {
-        db_id: %(id_func_name)s(e),
-        from_id: %(id_func_name)s(node_to_delete),
-        to_id: %(id_func_name)s(peer),
-        edge_type: type(e),
-        before_props: properties(e)
-    } AS edge_to_delete
-    UNION
-    WITH node_to_delete
-    MATCH (node_to_delete)<-[e]-(peer)
-    RETURN {
-        db_id: %(id_func_name)s(e),
-        from_id: %(id_func_name)s(peer),
-        to_id: %(id_func_name)s(node_to_delete),
-        edge_type: type(e),
-        before_props: properties(e)
-    } AS edge_to_delete
-}
-WITH node_to_delete, edges_to_create, collect(edge_to_delete) AS edges_to_delete
-RETURN
-    {db_id: %(id_func_name)s(node_to_delete), labels: labels(node_to_delete), before_props: properties(node_to_delete)} AS vertex_to_delete,
-    edges_to_create,
-    edges_to_delete
-        """ % {"id_func_name": self.db.get_id_function_name()}
-        results = await self.db.execute_query(query=query)
-        vertices_to_delete: list[VertexToDelete] = []
-        edges_to_delete: list[EdgeToDelete] = []
-        edges_to_add: list[EdgeToAdd] = []
-        for result in results:
-            serial_vertex_to_delete = result.get("vertex_to_delete")
-            if serial_vertex_to_delete:
-                vertex_to_delete = VertexToDelete(**serial_vertex_to_delete)
-                vertices_to_delete.append(vertex_to_delete)
-            for serial_edge_to_delete in result.get("edges_to_delete"):
-                edge_to_delete = EdgeToDelete(**serial_edge_to_delete)
-                edges_to_delete.append(edge_to_delete)
-            for serial_edge_to_create in result.get("edges_to_create"):
-                edges_to_add.append(EdgeToAdd(**serial_edge_to_create))
-        return PatchPlan(
-            name=self.name,
-            vertices_to_delete=vertices_to_delete,
-            edges_to_add=edges_to_add,
-            edges_to_delete=edges_to_delete,
-        )