test: Test support of SQLalchemy 2.0 syntax

Author: n0nSmoker

README.md

@@ -40,6 +40,41 @@ item = SomeModel.query.filter(...).one()
 result = item.to_dict()
 ```
 You get values of all SQLAlchemy fields in the `result` var, even nested relationships
+
+### Modern SQLAlchemy 2.0 Style
+
+**SerializerMixin** works seamlessly with both traditional SQLAlchemy style and modern SQLAlchemy 2.0 style using type annotations:
+
+**Traditional style:**
+```python
+from sqlalchemy_serializer import SerializerMixin
+import sqlalchemy as sa
+
+class SomeModel(db.Model, SerializerMixin):
+    id = sa.Column(sa.Integer, primary_key=True)
+    name = sa.Column(sa.String(256))
+```
+
+**Modern SQLAlchemy 2.0 style (also fully supported):**
+```python
+from __future__ import annotations
+
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy_serializer import SerializerMixin
+
+class ModernModel(Base, SerializerMixin):
+    __tablename__ = "modern_model"
+    
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(sa.String(256))
+    created_at: Mapped[datetime] = mapped_column(sa.DateTime, default=datetime.utcnow)
+    
+    # Relationships work too
+    parent_id: Mapped[int | None] = mapped_column(sa.ForeignKey("parent.id"), nullable=True)
+    parent: Mapped["ParentModel | None"] = relationship("ParentModel")
+```
+
+Both styles work identically with **SerializerMixin** - use whichever style you prefer!
 In order to change the default output you shuld pass tuple of fieldnames as an argument
 
 - If you want to exclude or add some extra fields (not from database)

tests/models.py

@@ -1,11 +1,12 @@
-from datetime import datetime
+from datetime import date, datetime, time
 from decimal import Decimal
+from uuid import UUID as UUIDType
 from uuid import uuid4
 
 import pytz
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.orm import declarative_base, relationship
+from sqlalchemy.orm import Mapped, declarative_base, mapped_column, relationship
 
 from sqlalchemy_serializer import SerializerMixin
 
@@ -124,3 +125,71 @@ class CustomSerializerModel(Base, CustomSerializerMixin):
     time = sa.Column(sa.Time, default=TIME)
     bool = sa.Column(sa.Boolean, default=True)
     money = MONEY
+
+
+# Modern SQLAlchemy 2.0 style models
+class ModernFlatModel(Base, SerializerMixin):
+    __tablename__ = "modern_flat_model"
+    serialize_only = ()
+    serialize_rules = ()
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    string: Mapped[str] = mapped_column(sa.String(256), default="Modern string with")
+    date_field: Mapped[date] = mapped_column(sa.Date, default=DATETIME)
+    datetime_field: Mapped[datetime] = mapped_column(sa.DateTime, default=DATETIME)
+    time_field: Mapped[time] = mapped_column(sa.Time, default=TIME)
+    bool_field: Mapped[bool] = mapped_column(sa.Boolean, default=True)
+    null: Mapped[str | None] = mapped_column(sa.String, nullable=True)
+    uuid: Mapped[UUIDType] = mapped_column(UUID(as_uuid=True), default=uuid4)
+    list = [1, "modern_test_string", 0.9, {"key": 123, "key2": 23423}, {"key": 234}]
+    set = {1, 2, "modern_test_string"}
+    dict = dict(key=123, key2={"key": 12})
+    money = MONEY
+
+    @property
+    def prop(self):
+        return "Modern property"
+
+    @property
+    def prop_with_bytes(self):
+        return b"Modern bytes"
+
+    def method(self):
+        return f"Modern method + {self.string}"
+
+    def _protected_method(self):
+        return f"Modern protected method + {self.string}"
+
+
+class ModernNestedModel(Base, SerializerMixin):
+    __tablename__ = "modern_nested_model"
+    serialize_only = ()
+    serialize_rules = ()
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    string: Mapped[str] = mapped_column(
+        sa.String(256), default="(MODERN_NESTED)Some string with"
+    )
+    date_field: Mapped[date] = mapped_column(sa.Date, default=DATETIME)
+    datetime_field: Mapped[datetime] = mapped_column(sa.DateTime, default=DATETIME)
+    time_field: Mapped[time] = mapped_column(sa.Time, default=TIME)
+    bool_field: Mapped[bool] = mapped_column(sa.Boolean, default=False)
+    null: Mapped[str | None] = mapped_column(sa.String, nullable=True)
+    list = [1, "(MODERN_NESTED)test_string", 0.9, {"key": 123}]
+    set = {1, 2, "(MODERN_NESTED)test_string"}
+    dict = dict(key=123)
+
+    model_id: Mapped[int | None] = mapped_column(
+        sa.ForeignKey("modern_flat_model.id"), nullable=True
+    )
+    model: Mapped["ModernFlatModel | None"] = relationship("ModernFlatModel")
+
+    @property
+    def prop(self):
+        return "(MODERN_NESTED)Some property"
+
+    def method(self):
+        return f"(MODERN_NESTED)User defined method + {self.string}"
+
+    def _protected_method(self):
+        return f"(MODERN_NESTED)User defined protected method + {self.string}"

tests/test_modern_models.py

@@ -0,0 +1,126 @@
+from .models import DATE, DATETIME, MONEY, TIME, ModernFlatModel, ModernNestedModel
+
+
+def test_modern_flat_model_basic(get_instance):
+    """Checks to_dict method of modern flat model with no predefined options"""
+    i = get_instance(ModernFlatModel)
+    data = i.to_dict()
+
+    # Check SQLAlchemy fields
+    assert "id" in data
+    assert "string" in data and data["string"] == i.string
+    assert "date_field" in data
+    assert "time_field" in data
+    assert "datetime_field" in data
+    assert "bool_field" in data and data["bool_field"] == i.bool_field
+    assert "null" in data and data["null"] is None
+    assert "uuid" in data and str(i.uuid) == data["uuid"]
+
+    # Check non-sql fields (not included in this case, need to be defined explicitly)
+    assert "list" not in data
+    assert "set" not in data
+    assert "dict" not in data
+    assert "prop" not in data
+    assert "method" not in data
+    assert "_protected_method" not in data
+    assert "money" not in data
+
+
+def test_modern_flat_model_with_properties(get_instance):
+    "Checks to_dict method of modern flat model with automatic serialization of @properties"
+
+    class AutoPropModernFlatModel(ModernFlatModel):
+        auto_serialize_properties = True
+
+    i = get_instance(AutoPropModernFlatModel)
+    data = i.to_dict()
+
+    # Check SQLAlchemy fields
+    assert "id" in data
+    assert "string" in data and data["string"] == i.string
+    assert "date_field" in data
+    assert "time_field" in data
+    assert "datetime_field" in data
+    assert "bool_field" in data and data["bool_field"] == i.bool_field
+    assert "null" in data and data["null"] is None
+    assert "uuid" in data and str(i.uuid) == data["uuid"]
+
+    # Properties
+    assert "prop" in data
+    assert "prop_with_bytes" in data
+
+    # Check non-sql fields
+    assert "list" not in data
+    assert "set" not in data
+    assert "dict" not in data
+    assert "method" not in data
+    assert "_protected_method" not in data
+    assert "money" not in data
+
+
+def test_modern_models_formats(get_instance):
+    """Check date/datetime/time/decimal default formats for modern models"""
+    i = get_instance(ModernFlatModel)
+
+    # Default formats
+    d_format = i.date_format
+    dt_format = i.datetime_format
+    t_format = i.time_format
+    decimal_format = i.decimal_format
+
+    # Include non-SQL field to check decimal_format and bytes
+    data = i.to_dict(rules=("money", "prop_with_bytes"))
+
+    assert "date_field" in data
+    assert data["date_field"] == DATE.strftime(d_format)
+    assert "datetime_field" in data
+    assert data["datetime_field"] == DATETIME.strftime(dt_format)
+    assert "time_field" in data
+    assert data["time_field"] == TIME.strftime(t_format)
+
+    assert "money" in data
+    assert data["money"] == decimal_format.format(MONEY)
+
+    assert "prop_with_bytes" in data
+    assert data["prop_with_bytes"] == i.prop_with_bytes.decode()
+
+
+def test_modern_nested_model(get_instance):
+    """Test relationship serialization with modern nested model"""
+    flat = get_instance(ModernFlatModel)
+    nested = get_instance(ModernNestedModel, model_id=flat.id)
+
+    # Test basic serialization
+    data = nested.to_dict()
+    assert "id" in data
+    assert "string" in data
+    assert "model_id" in data
+    assert data["model_id"] == flat.id
+
+    # Test relationship serialization
+    data_with_relation = nested.to_dict(rules=("model",))
+    assert "model" in data_with_relation
+    assert isinstance(data_with_relation["model"], dict)
+    assert data_with_relation["model"]["id"] == flat.id
+    assert data_with_relation["model"]["string"] == flat.string
+
+
+def test_modern_models_rules(get_instance):
+    """Test rules and only parameters with modern models"""
+    i = get_instance(ModernFlatModel)
+
+    # Test rules parameter
+    data = i.to_dict(rules=("-id", "prop", "method"))
+    assert "id" not in data
+    assert "string" in data
+    assert "prop" in data
+    assert data["prop"] == i.prop
+    assert "method" in data
+    assert data["method"] == i.method()
+
+    # Test only parameter
+    data_only = i.to_dict(only=("id", "string", "prop"))
+    assert "id" in data_only
+    assert "string" in data_only
+    assert "prop" in data_only
+    assert len(data_only.keys()) == 3