fix(BA-5983): preserve unset semantics in ModelDefinitionInput.to_draft

``ModelDefinitionInput.to_draft()`` used ``model_dump()`` with default
arguments, which dumps every field — including the unset ones at their
``None`` default. Round-tripping that through ``model_validate`` left
the resulting draft with ``model_fields_set`` containing every field,
so every ``None`` looked "explicitly set" and clobbered lower-priority
baselines during the revision merge chain.

Switch to ``model_dump(exclude_unset=True)`` so the resulting draft's
``model_fields_set`` reflects only what the caller actually provided.
This is what makes the BA-5983 scenario actually work end-to-end: a
request that omits ``name`` / ``model_path`` / ``service.port`` /
``health_check.path`` lets the variant baseline (or preset) fill them
in instead of nulling them out.

Extend the merge test to cover this directly — every "missing required
field" scenario now layers a baseline draft together with a request
draft so the merge actually combines fields across sources. Without
the fix, the model_path / service_port / health_check_path cases
would raise the wrong error first (e.g. ``ModelConfig.name is required``
fires before ``model_path``) because every request-side ``None`` would
clobber the baseline's preserved value.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jopemachine

src/ai/backend/common/dto/manager/v2/deployment/request.py

@@ -177,7 +177,12 @@ class ModelDefinitionInput(BaseRequestModel):
     models: list[ModelConfigInput] | None = None
 
     def to_draft(self) -> ModelDefinitionDraft:
-        return ModelDefinitionDraft.model_validate(self.model_dump())
+        # ``exclude_unset=True`` keeps the resulting draft's
+        # ``model_fields_set`` aligned with what the caller actually
+        # provided. Without it, every field would appear "explicitly
+        # set" (to ``None``) and clobber lower-priority sources during
+        # the revision merge.
+        return ModelDefinitionDraft.model_validate(self.model_dump(exclude_unset=True))
 
 
 class ClusterConfigInput(BaseRequestModel):

tests/unit/manager/sokovan/deployment/test_model_definition_merge.py

@@ -173,58 +173,104 @@ def test_merge_resolves_to_expected_values(
 class TestMergeRaisesWhenAllSourcesAreEmpty:
     """When neither the request nor any baseline source supplies a
     required field, ``to_resolved()`` must raise at the persistence
-    boundary — preserving the pre-BA-5983 contract."""
+    boundary — preserving the pre-BA-5983 contract.
+
+    Each scenario layers a baseline draft (variant-style) together with
+    a request draft so the merge actually combines fields across
+    sources; the target required field remains unfilled in every layer
+    and the resolved-time check fires on it specifically."""
 
     @pytest.mark.parametrize(
-        ("request_input", "error_pattern"),
+        ("drafts", "error_pattern"),
         [
             pytest.param(
-                ModelDefinitionInput(models=[ModelConfigInput(model_path="/p")]),
+                [
+                    # baseline supplies model_path; request adds nothing.
+                    RevisionDraft(
+                        model_definition=ModelDefinitionDraft(
+                            models=[ModelConfigDraft(model_path="/baseline/path")],
+                        ),
+                    ),
+                    RevisionDraft(
+                        model_definition=ModelDefinitionInput(
+                            models=[ModelConfigInput()],
+                        ).to_draft(),
+                    ),
+                ],
                 r"ModelConfig\.name is required",
-                id="missing_name",
+                id="name_unfilled_across_baseline_and_request",
             ),
             pytest.param(
-                ModelDefinitionInput(models=[ModelConfigInput(name="n")]),
+                [
+                    # baseline supplies name; request adds nothing.
+                    RevisionDraft(
+                        model_definition=ModelDefinitionDraft(
+                            models=[ModelConfigDraft(name="baseline-name")],
+                        ),
+                    ),
+                    RevisionDraft(
+                        model_definition=ModelDefinitionInput(
+                            models=[ModelConfigInput()],
+                        ).to_draft(),
+                    ),
+                ],
                 r"ModelConfig\.model_path is required",
-                id="missing_model_path",
+                id="model_path_unfilled_across_baseline_and_request",
             ),
             pytest.param(
-                ModelDefinitionInput(
-                    models=[
-                        ModelConfigInput(
-                            name="n",
-                            model_path="/p",
-                            service=ModelServiceConfigInput(),
-                        )
-                    ],
-                ),
+                [
+                    # baseline supplies the outer ModelConfig fields;
+                    # request adds an empty service (no port anywhere).
+                    RevisionDraft(
+                        model_definition=ModelDefinitionDraft(
+                            models=[ModelConfigDraft(name="n", model_path="/p")],
+                        ),
+                    ),
+                    RevisionDraft(
+                        model_definition=ModelDefinitionInput(
+                            models=[ModelConfigInput(service=ModelServiceConfigInput())],
+                        ).to_draft(),
+                    ),
+                ],
                 r"ModelServiceConfig\.port is required",
-                id="missing_service_port",
+                id="service_port_unfilled_across_baseline_and_request",
             ),
             pytest.param(
-                ModelDefinitionInput(
-                    models=[
-                        ModelConfigInput(
-                            name="n",
-                            model_path="/p",
-                            service=ModelServiceConfigInput(
-                                port=8080,
-                                health_check=ModelHealthCheckInput(),
-                            ),
-                        )
-                    ],
-                ),
+                [
+                    # baseline supplies a service with port; request adds
+                    # an empty health_check (no path anywhere).
+                    RevisionDraft(
+                        model_definition=ModelDefinitionDraft(
+                            models=[
+                                ModelConfigDraft(
+                                    name="n",
+                                    model_path="/p",
+                                    service=ModelServiceConfigDraft(port=8080),
+                                )
+                            ],
+                        ),
+                    ),
+                    RevisionDraft(
+                        model_definition=ModelDefinitionInput(
+                            models=[
+                                ModelConfigInput(
+                                    service=ModelServiceConfigInput(
+                                        health_check=ModelHealthCheckInput(),
+                                    ),
+                                )
+                            ],
+                        ).to_draft(),
+                    ),
+                ],
                 r"ModelHealthCheck\.path is required",
-                id="missing_health_check_path",
+                id="health_check_path_unfilled_across_baseline_and_request",
             ),
         ],
     )
-    def test_missing_required_field_raises(
-        self, request_input: ModelDefinitionInput, error_pattern: str
+    def test_required_field_unfilled_after_merge_raises(
+        self, drafts: list[RevisionDraft], error_pattern: str
     ) -> None:
-        request = RevisionDraft(model_definition=request_input.to_draft())
-
-        merged = _merge(request)
+        merged = _merge(*drafts)
 
         assert merged.model_definition is not None
         with pytest.raises(ValueError, match=error_pattern):