Add integration tests for infrahubctl object command

Author: dgarros

infrahub_sdk/ctl/cli_commands.py

@@ -62,7 +62,7 @@
 app.add_typer(validate_app, name="validate")
 app.add_typer(repository_app, name="repository")
 app.add_typer(menu_app, name="menu")
-app.add_typer(object_app, name="object", hidden=True)
+app.add_typer(object_app, name="object")
 
 app.command(name="dump")(dump)
 app.command(name="load")(load)

infrahub_sdk/schema/main.py

@@ -143,6 +143,7 @@ class RelationshipSchema(BaseModel):
 class RelationshipSchemaAPI(RelationshipSchema):
     model_config = ConfigDict(use_enum_values=True)
 
+    identifier: str
     inherited: bool = False
     read_only: bool = False
     hierarchical: str | None = None

infrahub_sdk/spec/object.py

@@ -4,11 +4,68 @@
 
 from pydantic import BaseModel, Field
 
+from ..schema import RelationshipSchema
 from ..yaml import InfrahubFile, InfrahubFileKind
 
 if TYPE_CHECKING:
     from ..client import InfrahubClient
-    from ..schema import MainSchemaTypesAPI
+    from ..node import InfrahubNode
+    from ..schema import MainSchemaTypesAPI, RelationshipSchema
+
+
+class RelationshipInfo(BaseModel):
+    name: str
+    rel_schema: RelationshipSchema
+    peer_kind: str
+    peer_rel: RelationshipSchema | None = None
+    is_reference: bool = True
+    reason_relationship_not_valid: str | None = None
+
+    @property
+    def is_bidirectional(self) -> bool:
+        return bool(self.peer_rel)
+
+    @property
+    def is_mandatory(self) -> bool:
+        if not self.peer_rel:
+            return False
+        return not self.peer_rel.optional
+
+    @property
+    def is_valid(self) -> bool:
+        return not self.reason_relationship_not_valid
+
+
+async def get_relationship_info(
+    client: InfrahubClient, schema: MainSchemaTypesAPI, key: str, value: Any, branch: str | None = None
+) -> RelationshipInfo:
+    """
+    Get the relationship info for a given relationship name.
+    """
+    rel_schema = schema.get_relationship(name=key)
+
+    info = RelationshipInfo(name=key, peer_kind=rel_schema.peer, rel_schema=rel_schema)
+
+    if isinstance(value, dict) and "data" not in value:
+        info.reason_relationship_not_valid = f"Relationship {key} must be a dict with 'data'"
+        return info
+
+    if isinstance(value, dict) and "kind" in value:
+        info.peer_kind = value["kind"]
+
+    peer_schema = await client.schema.get(kind=info.peer_kind, branch=branch)
+
+    try:
+        info.peer_rel = peer_schema.get_matching_relationship(id=rel_schema.identifier, direction=rel_schema.direction)
+    except ValueError:
+        pass
+
+    # Check if the content of the relationship is a reference to existing objects
+    #  or if it contains the data to create/update related objects
+    if isinstance(value, dict) and "data" in value:
+        info.is_reference = False
+
+    return info
 
 
 class InfrahubObjectFileData(BaseModel):
@@ -28,32 +85,60 @@ async def create_node(
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
-    ) -> None:
-        # First validate of all mandatory fields are present
+    ) -> InfrahubNode:
+        context = context or {}
+
+        # First validate if all mandatory fields are present
         for element in schema.mandatory_attribute_names + schema.mandatory_relationship_names:
-            if element not in data.keys():
+            if not any([element in data.keys(), element in context.keys()]):
                 raise ValueError(f"{element} is mandatory")
 
         clean_data: dict[str, Any] = {}
 
+        # List of relationships that need to be processed after the current object has been created
         remaining_rels = []
+        rels_info: dict[str, RelationshipInfo] = {}
+
         for key, value in data.items():
             if key in schema.attribute_names:
                 clean_data[key] = value
 
             if key in schema.relationship_names:
                 rel_schema = schema.get_relationship(name=key)
 
-                if isinstance(value, dict) and "data" not in value:
-                    raise ValueError(f"Relationship {key} must be a dict with 'data'")
+                rel_info = await get_relationship_info(
+                    client=client, schema=schema, key=key, value=value, branch=branch
+                )
+                rels_info[key] = rel_info
 
-                # This is a simple implementation for now, need to revisit once we have the integration tests
-                if isinstance(value, (list)):
+                if not rel_info.is_valid:
+                    client.log.info(rel_info.reason_relationship_not_valid)
+                    continue
+
+                # We need to determine if the related object depend on this object or if this is the other way around.
+                #  - if the relationship is bidirectional and is mandatory on the other side, then we need to create this object First
+                #  - if the relationship is bidirectional and is not mandatory on the other side, then we need should create the related object First
+                #  - if the relationship is not bidirectional, then we need to create the related object First
+                if rel_info.is_reference and isinstance(value, list):
                     clean_data[key] = value
-                elif rel_schema.cardinality == "one" and isinstance(value, str):
+                elif rel_info.is_reference and rel_schema.cardinality == "one" and isinstance(value, str):
                     clean_data[key] = [value]
-                else:
+                elif not rel_info.is_reference and rel_info.is_bidirectional and rel_info.is_mandatory:
                     remaining_rels.append(key)
+                elif not rel_info.is_reference and not rel_info.is_mandatory:
+                    nodes = await cls.create_related_nodes(
+                        client=client,
+                        rel_info=rel_info,
+                        data=value["data"],
+                        branch=branch,
+                        default_schema_kind=default_schema_kind,
+                    )
+                    if rel_info.rel_schema.cardinality == "one":
+                        clean_data[key] = nodes[0]
+                    else:
+                        clean_data[key] = nodes
+                else:
+                    raise ValueError(f"Situation unaccounted for: {rel_info}")
 
         if context:
             clean_context = {
@@ -67,53 +152,78 @@ async def create_node(
 
         node = await client.create(kind=schema.kind, branch=branch, data=clean_data)
         await node.save(allow_upsert=True)
+
         display_label = node.get_human_friendly_id_as_string() or f"{node.get_kind()} : {node.id}"
         client.log.info(f"Node: {display_label}")
 
         for rel in remaining_rels:
             # identify what is the name of the relationship on the other side
-            if not isinstance(data[rel], dict) and "data" in data[rel]:
-                raise ValueError(f"relationship {rel} must be a dict with 'data'")
-
-            rel_schema = schema.get_relationship(name=rel)
-            peer_kind = data[rel].get("kind", default_schema_kind) or rel_schema.peer
-            peer_schema = await client.schema.get(kind=peer_kind, branch=branch)
+            rel_info = rels_info[rel]
 
             if rel_schema.identifier is None:
                 raise ValueError("identifier must be defined")
 
-            peer_rel = peer_schema.get_matching_relationship(id=rel_schema.identifier, direction=rel_schema.direction)
-
             rel_data = data[rel]["data"]
             context = {}
-            if peer_rel:
-                context[peer_rel.name] = node.id
-
-            if rel_schema.cardinality == "one" and isinstance(rel_data, dict):
-                await cls.create_node(
-                    client=client,
-                    schema=peer_schema,
-                    data=rel_data,
-                    context=context,
-                    branch=branch,
-                    default_schema_kind=default_schema_kind,
-                )
 
-            elif rel_schema.cardinality == "many" and isinstance(rel_data, list):
-                for idx, peer_data in enumerate(rel_data):
-                    context["list_index"] = idx
-                    await cls.create_node(
+            if rel_info.peer_rel:
+                context[rel_info.peer_rel.name] = node.id
+
+            await cls.create_related_nodes(
+                client=client,
+                rel_info=rel_info,
+                data=rel_data,
+                context=context,
+                branch=branch,
+                default_schema_kind=default_schema_kind,
+            )
+
+        return node
+
+    @classmethod
+    async def create_related_nodes(
+        cls,
+        client: InfrahubClient,
+        rel_info: RelationshipInfo,
+        data: dict,
+        context: dict | None = None,
+        branch: str | None = None,
+        default_schema_kind: str | None = None,
+    ) -> list[InfrahubNode]:
+        peer_schema = await client.schema.get(kind=rel_info.peer_kind, branch=branch)
+
+        nodes: list[InfrahubNode] = []
+
+        if rel_info.rel_schema.cardinality == "one" and isinstance(data, dict):
+            node = await cls.create_node(
+                client=client,
+                schema=peer_schema,
+                data=data,
+                context=context,
+                branch=branch,
+                default_schema_kind=default_schema_kind,
+            )
+            return [node]
+
+        if rel_info.rel_schema.cardinality == "many" and isinstance(data, list):
+            context = context or {}
+            for idx, peer_data in enumerate(data):
+                context["list_index"] = idx
+                if isinstance(peer_data, dict):
+                    node = await cls.create_node(
                         client=client,
                         schema=peer_schema,
                         data=peer_data,
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
                     )
-            else:
-                raise ValueError(
-                    f"Relationship {rel_schema.name} doesn't have the right format {rel_schema.cardinality} / {type(rel_data)}"
-                )
+                    nodes.append(node)
+            return nodes
+
+        raise ValueError(
+            f"Relationship {rel_info.rel_schema.name} doesn't have the right format {rel_info.rel_schema.cardinality} / {type(data)}"
+        )
 
 
 class ObjectFile(InfrahubFile):

infrahub_sdk/testing/schemas/animal.py

@@ -20,6 +20,7 @@
 TESTING_CAT = f"{NAMESPACE}Cat"
 TESTING_DOG = f"{NAMESPACE}Dog"
 TESTING_PERSON = f"{NAMESPACE}Person"
+BUILTIN_TAG = "BuiltinTag"
 
 
 class SchemaAnimal:
@@ -125,6 +126,12 @@ def schema_person(self) -> NodeSchema:
                     cardinality="many",
                     direction=RelationshipDirection.INBOUND,
                 ),
+                Rel(
+                    name="tags",
+                    optional=True,
+                    peer=BUILTIN_TAG,
+                    cardinality="many",
+                ),
             ],
         )
 

infrahub_sdk/yaml.py

@@ -25,7 +25,7 @@ class InfrahubFileData(BaseModel):
     api_version: InfrahubFileApiVersion = Field(InfrahubFileApiVersion.V1, alias="apiVersion")
     kind: InfrahubFileKind
     spec: dict
-    metadata: dict | None = Field(default_factory=dict)
+    metadata: dict | None = Field(default_factory=dict)  # type: ignore[arg-type]
 
 
 class LocalFile(BaseModel):