fix: robust synthetic property handling for Collections

- Refactored SavedCollection and CollectionWithUrn to ensure robust handling of synthetic and required fields for both ORM and dict contexts.
- Added parameterized tests to verify all key attributes are correctly handled in both construction modes.
- Added tests for creation from both dict and ORM contexts, mirroring the approach used for other models.

Author: bencap

src/mavedb/view_models/collection.py

@@ -1,5 +1,5 @@
 from datetime import date
-from typing import Any, Sequence, Optional
+from typing import Any, Optional, Sequence
 
 from pydantic import Field, model_validator
 
@@ -84,36 +84,36 @@ class Config:
         from_attributes = True
 
     # These 'synthetic' fields are generated from other model properties. Transform data from other properties as needed, setting
-    # the appropriate field on the model itself. Then, proceed with Pydantic ingestion once fields are created.
+    # the appropriate field on the model itself. Then, proceed with Pydantic ingestion once fields are created. Only perform these
+    # transformations if the relevant attributes are present on the input data (i.e., when creating from an ORM object).
     @model_validator(mode="before")
     def generate_contribution_role_user_relationships(cls, data: Any):
-        try:
-            user_associations = transform_contribution_role_associations_to_roles(data.user_associations)
-            for k, v in user_associations.items():
-                data.__setattr__(k, v)
-
-        except AttributeError as exc:
-            raise ValidationError(
-                f"Unable to create {cls.__name__} without attribute: {exc}."  # type: ignore
-            )
+        if hasattr(data, "user_associations"):
+            try:
+                user_associations = transform_contribution_role_associations_to_roles(data.user_associations)
+                for k, v in user_associations.items():
+                    data.__setattr__(k, v)
+
+            except (AttributeError, KeyError) as exc:
+                raise ValidationError(f"Unable to coerce user associations for {cls.__name__}: {exc}.")
         return data
 
     @model_validator(mode="before")
     def generate_score_set_urn_list(cls, data: Any):
-        if not hasattr(data, "score_set_urns"):
+        if hasattr(data, "score_sets"):
             try:
                 data.__setattr__("score_set_urns", transform_score_set_list_to_urn_list(data.score_sets))
-            except AttributeError as exc:
-                raise ValidationError(f"Unable to create {cls.__name__} without attribute: {exc}.")  # type: ignore
+            except (AttributeError, KeyError) as exc:
+                raise ValidationError(f"Unable to coerce score set urns for {cls.__name__}: {exc}.")
         return data
 
     @model_validator(mode="before")
     def generate_experiment_urn_list(cls, data: Any):
-        if not hasattr(data, "experiment_urns"):
+        if hasattr(data, "experiments"):
             try:
                 data.__setattr__("experiment_urns", transform_experiment_list_to_urn_list(data.experiments))
-            except AttributeError as exc:
-                raise ValidationError(f"Unable to create {cls.__name__} without attribute: {exc}.")  # type: ignore
+            except (AttributeError, KeyError) as exc:
+                raise ValidationError(f"Unable to coerce experiment urns for {cls.__name__}: {exc}.")
         return data
 
 

tests/view_models/test_collection.py

@@ -0,0 +1,120 @@
+import pytest
+from pydantic import ValidationError
+
+from mavedb.models.enums.contribution_role import ContributionRole
+from mavedb.view_models.collection import Collection, SavedCollection
+from tests.helpers.constants import TEST_COLLECTION_RESPONSE
+from tests.helpers.util.common import dummy_attributed_object_from_dict
+
+
+@pytest.mark.parametrize(
+    "exclude,expected_missing_fields",
+    [
+        ("user_associations", ["admins", "editors", "viewers"]),
+        ("score_sets", ["scoreSetUrns"]),
+        ("experiments", ["experimentUrns"]),
+    ],
+)
+def test_cannot_create_saved_experiment_without_all_attributed_properties(exclude, expected_missing_fields):
+    collection = TEST_COLLECTION_RESPONSE.copy()
+    collection["urn"] = "urn:mavedb:collection-xxx"
+
+    # Remove pre-existing synthetic properties
+    collection.pop("experimentUrns", None)
+    collection.pop("scoreSetUrns", None)
+    collection.pop("admins", None)
+    collection.pop("editors", None)
+    collection.pop("viewers", None)
+
+    # Set synthetic properties with dummy attributed objects to mock SQLAlchemy model objects.
+    collection["experiments"] = [dummy_attributed_object_from_dict({"urn": "urn:mavedb:experiment-xxx"})]
+    collection["score_sets"] = [
+        dummy_attributed_object_from_dict({"urn": "urn:mavedb:score_set-xxx", "superseding_score_set": None})
+    ]
+    collection["user_associations"] = [
+        dummy_attributed_object_from_dict(
+            {
+                "contribution_role": ContributionRole.admin,
+                "user": {"id": 1, "username": "test_user", "email": "[email protected]"},
+            }
+        ),
+        dummy_attributed_object_from_dict(
+            {
+                "contribution_role": ContributionRole.editor,
+                "user": {"id": 1, "username": "test_user", "email": "[email protected]"},
+            }
+        ),
+        dummy_attributed_object_from_dict(
+            {
+                "contribution_role": ContributionRole.viewer,
+                "user": {"id": 1, "username": "test_user", "email": "[email protected]"},
+            }
+        ),
+    ]
+
+    collection.pop(exclude)
+    collection_attributed_object = dummy_attributed_object_from_dict(collection)
+    with pytest.raises(ValidationError) as exc_info:
+        SavedCollection.model_validate(collection_attributed_object)
+
+    # Should fail with missing fields coerced from missing attributed properties
+    msg = str(exc_info.value)
+    assert "Field required" in msg
+    for field in expected_missing_fields:
+        assert field in msg
+
+
+def test_saved_collection_can_be_created_with_all_attributed_properties():
+    collection = TEST_COLLECTION_RESPONSE.copy()
+    urn = "urn:mavedb:collection-xxx"
+    collection["urn"] = urn
+
+    # Remove pre-existing synthetic properties
+    collection.pop("experimentUrns", None)
+    collection.pop("scoreSetUrns", None)
+    collection.pop("admins", None)
+    collection.pop("editors", None)
+    collection.pop("viewers", None)
+
+    # Set synthetic properties with dummy attributed objects to mock SQLAlchemy model objects.
+    collection["experiments"] = [dummy_attributed_object_from_dict({"urn": "urn:mavedb:experiment-xxx"})]
+    collection["score_sets"] = [
+        dummy_attributed_object_from_dict({"urn": "urn:mavedb:score_set-xxx", "superseding_score_set": None})
+    ]
+    collection["user_associations"] = [
+        dummy_attributed_object_from_dict(
+            {
+                "contribution_role": ContributionRole.admin,
+                "user": {"id": 1, "username": "test_user", "email": "[email protected]"},
+            }
+        ),
+        dummy_attributed_object_from_dict(
+            {
+                "contribution_role": ContributionRole.editor,
+                "user": {"id": 1, "username": "test_user", "email": "[email protected]"},
+            }
+        ),
+        dummy_attributed_object_from_dict(
+            {
+                "contribution_role": ContributionRole.viewer,
+                "user": {"id": 1, "username": "test_user", "email": "[email protected]"},
+            }
+        ),
+    ]
+
+    collection_attributed_object = dummy_attributed_object_from_dict(collection)
+    model = SavedCollection.model_validate(collection_attributed_object)
+    assert model.name == TEST_COLLECTION_RESPONSE["name"]
+    assert model.urn == urn
+    assert len(model.admins) == 1
+    assert len(model.editors) == 1
+    assert len(model.viewers) == 1
+    assert len(model.experiment_urns) == 1
+    assert len(model.score_set_urns) == 1
+
+
+def test_collection_can_be_created_from_non_orm_context():
+    data = dict(TEST_COLLECTION_RESPONSE)
+    data["urn"] = "urn:mavedb:collection-xxx"
+    model = Collection.model_validate(data)
+    assert model.urn == data["urn"]