Fix deployment tests

Author: shangyian

datajunction-server/datajunction_server/database/column.py

@@ -164,7 +164,6 @@ def copy(self) -> "Column":
         """
         Returns a full copy of the column
         """
-        print("self.type", self.name, self.type)
         return Column(
             order=self.order,
             name=self.name,

datajunction-server/datajunction_server/internal/deployment.py

@@ -455,7 +455,7 @@ async def check_external_deps(
         if len(external_node_deps) != len(deps_not_in_deployment):
             missing_nodes = sorted(
                 set(deps_not_in_deployment)
-                - {node.name for node in external_node_deps},
+                - {node.rendered_name for node in external_node_deps},
             )
             raise DJInvalidDeploymentConfig(
                 message=(

datajunction-server/datajunction_server/models/deployment.py

@@ -1,7 +1,14 @@
 from enum import Enum
-from pydantic import BaseModel, Field, field_validator, PrivateAttr, ConfigDict
+from pydantic import (
+    BaseModel,
+    Field,
+    field_validator,
+    PrivateAttr,
+    ConfigDict,
+    model_validator,
+)
 
-from typing import Any, Literal, Union
+from typing import Annotated, Any, Literal, Union
 
 from datajunction_server.models.partition import Granularity, PartitionType
 from datajunction_server.errors import DJInvalidInputException
@@ -40,8 +47,8 @@ class PartitionSpec(BaseModel):
     """
 
     type: PartitionType
-    granularity: Granularity | None
-    format: str | None
+    granularity: Granularity | None = None
+    format: str | None = None
 
 
 class ColumnSpec(BaseModel):
@@ -91,7 +98,7 @@ class DimensionJoinLinkSpec(DimensionLinkSpec):
     """
 
     dimension_node: str
-    type: LinkType = LinkType.JOIN
+    type: Literal[LinkType.JOIN] = LinkType.JOIN
 
     node_column: str | None = None
     join_type: JoinType = JoinType.LEFT
@@ -147,7 +154,7 @@ class DimensionReferenceLinkSpec(DimensionLinkSpec):
 
     node_column: str
     dimension: str
-    type: LinkType = LinkType.REFERENCE
+    type: Literal[LinkType.REFERENCE] = LinkType.REFERENCE
 
     @property
     def rendered_dimension_node(self) -> str:
@@ -262,31 +269,23 @@ class LinkableNodeSpec(NodeSpec):
     """
 
     columns: list[ColumnSpec] | None = None
-    dimension_links: list[DimensionJoinLinkSpec | DimensionReferenceLinkSpec] = Field(
-        default_factory=list,
-    )
+    dimension_links: list[
+        Annotated[
+            DimensionJoinLinkSpec | DimensionReferenceLinkSpec,
+            Field(discriminator="type"),
+        ]
+    ] = Field(default_factory=list)
     primary_key: list[str] = Field(default_factory=list)
 
-    @field_validator("dimension_links", mode="before")
-    def coerce_dimension_links(cls, values):
-        if not isinstance(values, list):
-            values = [values]
-        result = []
-        for value in values:
-            if isinstance(value, dict):
-                link_type = value.get("type")
-                mapping = {
-                    "join": DimensionJoinLinkSpec,
-                    "reference": DimensionReferenceLinkSpec,
-                }
-                if link_type not in mapping:  # pragma: no cover
-                    raise ValueError(f"Unknown link type: {link_type}")
-                deployment_ns = getattr(cls, "namespace", None)
-                result.append(mapping[link_type](**value, namespace=deployment_ns))
-            else:
-                value.namespace = getattr(cls, "namespace", None)
-                result.append(value)
-        return result
+    @model_validator(mode="after")
+    def set_namespaces(self):
+        """
+        Set namespace on all dimension links
+        """
+        if self.namespace:
+            for link in self.dimension_links:
+                link.namespace = self.namespace
+        return self
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, LinkableNodeSpec):
@@ -365,11 +364,11 @@ class MetricSpec(NodeSpec):
     query: str
     required_dimensions: list[str] | None = None
     direction: MetricDirection | None = None
-    unit_enum: MetricUnit | None = Field(None, exclude=True)
+    unit_enum: MetricUnit | None = Field(default=None, exclude=True)
 
     significant_digits: int | None = None
-    min_decimal_exponent: int | None
-    max_decimal_exponent: int | None
+    min_decimal_exponent: int | None = None
+    max_decimal_exponent: int | None = None
 
     def __init__(self, **data: Any):
         unit = data.pop("unit", None)
@@ -445,12 +444,15 @@ def __eq__(self, other: Any) -> bool:
         )
 
 
-NodeUnion = Union[
-    SourceSpec,
-    TransformSpec,
-    DimensionSpec,
-    MetricSpec,
-    CubeSpec,
+NodeUnion = Annotated[
+    Union[
+        SourceSpec,
+        TransformSpec,
+        DimensionSpec,
+        MetricSpec,
+        CubeSpec,
+    ],
+    Field(discriminator="node_type"),
 ]
 
 
@@ -488,28 +490,23 @@ class DeploymentSpec(BaseModel):
     nodes: list[NodeUnion] = Field(default_factory=list)
     tags: list[TagSpec] = Field(default_factory=list)
 
-    @field_validator("nodes", mode="before")
-    def coerce_nodes(cls, values):
-        if not isinstance(values, list):
-            values = [values]
-        result = []
-        for value in values:
-            if isinstance(value, dict):
-                node_type = value.get("node_type")
-                mapping = {
-                    "source": SourceSpec,
-                    "transform": TransformSpec,
-                    "dimension": DimensionSpec,
-                    "metric": MetricSpec,
-                    "cube": CubeSpec,
-                }
-                if node_type not in mapping:  # pragma: no cover
-                    raise ValueError(f"Unknown node_type: {node_type}")
-                deployment_ns = getattr(cls, "namespace", None)
-                result.append(mapping[node_type](**value, namespace=deployment_ns))
-            else:
-                result.append(value)
-        return result
+    @model_validator(mode="after")
+    def set_namespaces(self):
+        """
+        Set namespace on all node specs and their dimension links
+        """
+        if hasattr(self, "nodes") and hasattr(self, "namespace") and self.namespace:
+            for node in self.nodes:
+                # Set namespace on the node itself
+                if hasattr(node, "namespace") and not node.namespace:
+                    node.namespace = self.namespace
+
+                # Set namespace on dimension links (for LinkableNodeSpec subclasses)
+                if hasattr(node, "dimension_links") and node.dimension_links:
+                    for link in node.dimension_links:
+                        if not link.namespace:
+                            link.namespace = self.namespace
+        return self
 
 
 class VersionedNode(BaseModel):

datajunction-server/tests/api/data_test.py

@@ -995,7 +995,6 @@ async def test_raising_when_node_does_not_exist(
             },
         )
         data = response.json()
-        print("response!!", data)
 
         assert response.status_code == 404
         assert data == {

datajunction-server/tests/api/nodes_test.py

@@ -1571,8 +1571,7 @@ async def test_register_view_with_query_service(
         """
         Registering a view with a query service set up should succeed.
         """
-        res = await module__client_with_basic.get("/catalogs")
-        print("catalogs!", res.json())
+        await module__client_with_basic.get("/catalogs")
         response = await module__client_with_basic.post(
             "/register/view/public/main/view_foo?query=SELECT+1+AS+one+,+'two'+AS+two",
         )
@@ -2072,7 +2071,6 @@ async def test_create_update_source_node(
             },
         )
         data = response.json()
-        print("data!!", data)
 
         assert data["name"] == "basic.source.comments"
         assert data["display_name"] == "Comments facts"