Merge release-1.7 into develop

.github/workflows/ci.yml

@@ -848,7 +848,7 @@ jobs:
       needs.files-changed.outputs.e2e == 'true'
     runs-on:
       group: huge-runners
-    timeout-minutes: 40
+    timeout-minutes: 60
     strategy:
       fail-fast: false
       matrix:

backend/infrahub/core/migrations/schema/attribute_kind_update.py

@@ -40,7 +40,7 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> No
 // ------------
 // start with all the Attribute vertices we might care about
 // ------------
-MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+MATCH (n:%(schema_kinds)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
 WHERE attr.name = $attr_name
 WITH DISTINCT n, attr
 
@@ -76,7 +76,7 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> No
 // ------------
 WITH 1 AS one
 LIMIT 1
-MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+MATCH (n:%(schema_kinds)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
 WHERE attr.name = $attr_name
 WITH DISTINCT n, attr
 
@@ -94,7 +94,6 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> No
     RETURN has_value_e, av
 }
 
-
 // ------------
 // create and update the HAS_VALUE edges
 // ------------
@@ -154,7 +153,9 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> No
     SET n.updated_at = $at, n.updated_by = $user_id
 }
         """ % {
-            "schema_kind": self.migration.previous_schema.kind,
+            "schema_kinds": (
+                f"{self.migration.previous_schema.kind}|Profile{self.migration.previous_schema.kind}|Template{self.migration.previous_schema.kind}"
+            ),
             "branch_filter": branch_filter,
             "new_attr_value_labels": new_attr_value_labels,
         }

backend/infrahub/core/schema/attribute_parameters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Self
+from typing import Any, Self
 
 from pydantic import ConfigDict, Field, model_validator
 
@@ -24,6 +24,33 @@ def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParamete
 class AttributeParameters(HashableModel):
     model_config = ConfigDict(extra="forbid")
 
+    @classmethod
+    def convert_from(cls, source: AttributeParameters) -> Self:
+        """Convert from another AttributeParameters subclass.
+
+        Args:
+            source: The source AttributeParameters instance to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        source_data = source.model_dump()
+        return cls.convert_from_dict(source_data=source_data)
+
+    @classmethod
+    def convert_from_dict(cls, source_data: dict[str, Any]) -> Self:
+        """Convert from a dictionary to the target class.
+
+        Args:
+            source_data: The source dictionary to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        target_fields = set(cls.model_fields.keys())
+        filtered_data = {k: v for k, v in source_data.items() if k in target_fields}
+        return cls(**filtered_data)
+
 
 class TextAttributeParameters(AttributeParameters):
     regex: str | None = Field(

backend/infrahub/core/schema/attribute_schema.py

@@ -114,13 +114,20 @@ def validate_dropdown_choices(cls, values: Any) -> Any:
     @field_validator("parameters", mode="before")
     @classmethod
     def set_parameters_type(cls, value: Any, info: ValidationInfo) -> Any:
-        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
+        """Override parameters class if using base AttributeParameters class and should be using a subclass.
+
+        This validator handles parameter type conversion when an attribute's kind changes.
+        Fields from the source that don't exist in the target are silently dropped.
+        Fields with the same name in both classes are preserved.
+        """
         kind = info.data["kind"]
         expected_parameters_class = get_attribute_parameters_class_for_kind(kind=kind)
         if value is None:
             return expected_parameters_class()
         if not isinstance(value, expected_parameters_class) and isinstance(value, AttributeParameters):
-            return expected_parameters_class(**value.model_dump())
+            return expected_parameters_class.convert_from(value)
+        if isinstance(value, dict):
+            return expected_parameters_class.convert_from_dict(source_data=value)
         return value
 
     @model_validator(mode="after")

backend/infrahub/core/validators/attribute/kind.py

@@ -36,7 +36,7 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> No
         self.params["null_value"] = NULL_VALUE
 
         query = """
-        MATCH p = (n:%(node_kind)s)
+        MATCH (n:%(node_kinds)s)
         CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
@@ -51,7 +51,10 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> No
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value
-        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kinds": f"{self.node_schema.kind}|Profile{self.node_schema.kind}|Template{self.node_schema.kind}",
+        }
 
         self.add_to_query(query)
         self.return_labels = ["node.uuid", "attribute_value", "value_relationship.branch as value_branch"]

backend/tests/conftest.py

@@ -146,6 +146,11 @@ async def _db(singleton: bool = True) -> InfrahubDatabase:
         await driver.close()
 
 
+@pytest.fixture(scope="class")
+async def db_class() -> InfrahubDatabase:
+    return await build_database(singleton=False)
+
+
 @pytest.fixture
 async def empty_database(db: InfrahubDatabase) -> None:
     await do_empty_database(db=db)
@@ -449,6 +454,13 @@ def prefect_container(request: pytest.FixtureRequest, load_settings_before_sessi
     return start_prefect_server_container(request)
 
 
+@pytest.fixture(scope="class")
+def prefect_container_class(
+    request: pytest.FixtureRequest, load_settings_before_session: None
+) -> dict[int, int] | None:
+    return start_prefect_server_container(request)
+
+
 @pytest.fixture(scope="module")
 def prefect(
     prefect_container: dict[int, int] | None, reload_settings_before_each_module: None
@@ -470,6 +482,27 @@ def prefect(
         yield server_api_url
 
 
+@pytest.fixture(scope="class")
+def prefect_class(
+    prefect_container_class: dict[int, int] | None, reload_settings_before_each_module: None
+) -> Generator[str, None, None]:
+    if prefect_container_class:
+        server_port = prefect_container_class[PORT_PREFECT]
+        server_api_url = f"http://localhost:{server_port}/api"
+    else:
+        server_api_url = f"http://localhost:{PORT_PREFECT}/api"
+
+    with ExitStack() as stack:
+        stack.enter_context(
+            prefect_settings.temporary_settings(
+                updates={
+                    prefect_settings.PREFECT_API_URL: server_api_url,
+                }
+            )
+        )
+        yield server_api_url
+
+
 @pytest.fixture(scope="session", autouse=True)
 def load_settings_before_session() -> None:
     load_and_exit()

backend/tests/helpers/test_app.py

@@ -125,6 +125,7 @@ async def test_client(
         self,
         dependency_provider: Provider,
         db: InfrahubDatabase,
+        db_class: InfrahubDatabase,
         initialize_registry: None,
         redis: dict[int, int] | None,
         nats: dict[int, int] | None,
@@ -135,7 +136,7 @@ async def test_client(
         # NOTE 2: FastAPI does not have an asynchronous TestClient, thus we rely on httpx.AsyncClient which does not trigger
         # lifespan events (see https://fastapi.tiangolo.com/advanced/async-tests/#in-detail).
         async def _db(singleton: bool = True) -> InfrahubDatabase:
-            return await build_database(singleton=False)
+            return db_class
 
         with dependency_provider.scope(build_database, _db):
             async with lifespan(app):

backend/tests/helpers/test_worker.py

@@ -1,11 +1,9 @@
 import asyncio
-from contextlib import ExitStack
-from typing import Any, AsyncGenerator, Generator
+from typing import Any, AsyncGenerator
 from uuid import UUID
 
 import pytest
 from infrahub_sdk import InfrahubClient
-from prefect import settings as prefect_settings
 from prefect.client.orchestration import PrefectClient
 from prefect.client.schemas.actions import WorkPoolCreate
 from prefect.client.schemas.filters import WorkPoolFilter, WorkPoolFilterId
@@ -22,11 +20,7 @@
 from infrahub.workflows.catalogue import INFRAHUB_WORKER_POOL
 from infrahub.workflows.initialization import setup_blocks
 from infrahub.workflows.models import WorkerPoolDefinition
-from tests.helpers.constants import (
-    PORT_PREFECT,
-)
 from tests.helpers.test_app import TestInfrahubAppWithoutLocalWorkflow
-from tests.helpers.utils import start_prefect_server_container
 
 
 class TestWorkerInfrahubAsync(TestInfrahubAppWithoutLocalWorkflow):
@@ -62,34 +56,8 @@ async def worker_run_flow(
         )
 
     @pytest.fixture(scope="class")
-    def prefect_container_class(
-        self, request: pytest.FixtureRequest, load_settings_before_session: Any
-    ) -> dict[int, int] | None:
-        return start_prefect_server_container(request)
-
-    @pytest.fixture(scope="class")
-    def prefect_server(
-        self, prefect_container_class: dict[int, int] | None, reload_settings_before_each_module: Any
-    ) -> Generator[str, None, None]:
-        if prefect_container_class:
-            server_port = prefect_container_class[PORT_PREFECT]
-            server_api_url = f"http://localhost:{server_port}/api"
-        else:
-            server_api_url = f"http://localhost:{PORT_PREFECT}/api"
-
-        with ExitStack() as stack:
-            stack.enter_context(
-                prefect_settings.temporary_settings(
-                    updates={
-                        prefect_settings.PREFECT_API_URL: server_api_url,
-                    }
-                )
-            )
-            yield server_api_url
-
-    @pytest.fixture(scope="class")
-    async def prefect_client(self, prefect_server: str) -> PrefectClient:
-        return PrefectClient(api=prefect_server)
+    async def prefect_client(self, prefect_class: str) -> PrefectClient:
+        return PrefectClient(api=prefect_class)
 
     @pytest.fixture(scope="class")
     async def work_pool(self, prefect_client: PrefectClient) -> WorkPool:

backend/tests/integration/git/test_git_repository.py

@@ -1,7 +1,9 @@
 from pathlib import Path
+from typing import AsyncGenerator
 
 import pytest
 import yaml
+from fast_depends import dependency_provider
 from infrahub_sdk import Config, InfrahubClient
 from infrahub_sdk.exceptions import NodeNotFoundError
 from infrahub_sdk.protocols import CoreCheckDefinition, CoreGraphQLQuery, CoreTransformJinja2, CoreTransformPython
@@ -15,9 +17,10 @@
 from infrahub.core.utils import count_relationships, delete_all_nodes
 from infrahub.database import InfrahubDatabase
 from infrahub.git import InfrahubRepository
-from infrahub.server import app, app_initialization
+from infrahub.server import app, lifespan
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from infrahub.utils import get_models_dir
+from infrahub.workers.dependencies import build_database
 from infrahub.workflows.initialization import setup_task_manager
 from tests.helpers.file_repo import FileRepo
 from tests.helpers.test_app import TestInfrahubApp
@@ -65,9 +68,14 @@ async def test_client(
         self,
         base_dataset,
         workflow_local,
-    ) -> InfrahubTestClient:
-        await app_initialization(app)
-        return InfrahubTestClient(app=app)
+        db_class: InfrahubDatabase,
+    ) -> AsyncGenerator[InfrahubTestClient, None]:
+        async def _db(singleton: bool = True) -> InfrahubDatabase:
+            return db_class
+
+        with dependency_provider.scope(build_database, _db):
+            async with lifespan(app):
+                yield InfrahubTestClient(app=app)
 
     @pytest.fixture
     async def client(self, test_client: InfrahubTestClient, integration_helper) -> InfrahubClient: