chore: Improve the test coverage. Add error handling tests

Author: n0nSmoker

sqlalchemy_serializer/lib/schema.py

@@ -35,7 +35,7 @@ def to_strict(self):
                 continue  # Exclude leafs
             tree.to_strict()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         include = f"to_include={self.to_include}"
         exclude = f"to_exclude={self.to_exclude}"
         greedy = f"is_greedy={self.is_greedy}"

sqlalchemy_serializer/lib/serializable/base.py

@@ -1,3 +1,6 @@
+from abc import abstractmethod
+
+
 class Base:
-    def __call__(self, value) -> str:
-        raise NotImplementedError(f"Method should implement serialization logic for {value}")
+    @abstractmethod
+    def __call__(self, value) -> str: ...

sqlalchemy_serializer/lib/serializable/time.py

@@ -8,5 +8,5 @@ class Time(Base):
     def __init__(self, str_format: str = "%H:%M:%S") -> None:
         self.str_format = str_format
 
-    def __call__(self, value: datetime.time):
+    def __call__(self, value: datetime.time) -> str:
         return format_dt(tpl=self.str_format, dt=value)

sqlalchemy_serializer/lib/serializable/uuid.py

@@ -4,5 +4,5 @@
 
 
 class UUID(Base):
-    def __call__(self, value: uuid.UUID):
+    def __call__(self, value: uuid.UUID) -> str:
         return str(value)

tests/conftest.py

@@ -10,7 +10,7 @@
 from .models import Base
 
 logger = logging.getLogger("serializer")
-logger.setLevel(logging.DEBUG)
+logger.setLevel(logging.INFO)
 
 
 DEFAULT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"

tests/test_error_handling.py

@@ -0,0 +1,85 @@
+"""Error handling tests for SQLAlchemy serializer."""
+
+import pytest
+import sqlalchemy as sa
+
+from sqlalchemy_serializer import SerializerMixin
+
+from .models import Base
+
+
+class ModelWithFailingProperty(Base, SerializerMixin):
+    """Model with a property that raises an exception."""
+
+    __tablename__ = "model_with_failing_property"
+    serialize_only = ()
+    serialize_rules = ()
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    string = sa.Column(sa.String(256), default="test")
+
+    @property
+    def failing_prop(self):
+        """Property that raises an exception."""
+        raise ValueError("Property access failed")
+
+    @property
+    def valid_prop(self):
+        """Property that works correctly."""
+        return "valid value"
+
+
+class ModelWithFailingMethod(Base, SerializerMixin):
+    """Model with a method that raises an exception."""
+
+    __tablename__ = "model_with_failing_method"
+    serialize_only = ()
+    serialize_rules = ()
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    string = sa.Column(sa.String(256), default="test")
+
+    def failing_method(self):
+        """Method that raises an exception."""
+        raise RuntimeError("Method call failed")
+
+    def valid_method(self):
+        """Method that works correctly."""
+        return "valid result"
+
+
+class ModelWithFailingCustomSerializer(Base, SerializerMixin):
+    """Model with custom serializer that raises an exception."""
+
+    __tablename__ = "model_with_failing_custom_serializer"
+    serialize_only = ()
+    serialize_rules = ()
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    string = sa.Column(sa.String(256), default="test")
+    number = sa.Column(sa.Integer, default=42)
+
+
+def test_property_raises_exception_default_behavior(get_instance):
+    model = get_instance(ModelWithFailingProperty)
+
+    with pytest.raises(ValueError, match="Property access failed"):
+        model.to_dict(rules=("failing_prop",))
+
+
+def test_method_raises_exception_default_behavior(get_instance):
+    model = get_instance(ModelWithFailingMethod)
+
+    with pytest.raises(RuntimeError, match="Method call failed"):
+        model.to_dict(rules=("failing_method",))
+
+
+def test_custom_serializer_raises_exception_default_behavior(get_instance):
+    model = get_instance(ModelWithFailingCustomSerializer)
+
+    def failing_serializer(_value):
+        """Custom serializer that raises an exception."""
+        raise TypeError("Custom serializer failed")
+
+    with pytest.raises(TypeError, match="Custom serializer failed"):
+        model.to_dict(serialize_columns={"string": failing_serializer})

tests/test_is_valid_callable.py

@@ -0,0 +1,92 @@
+"""Tests for Serializer.is_valid_callable static method."""
+
+import inspect
+from types import MethodType
+
+import sqlalchemy as sa
+
+from sqlalchemy_serializer import SerializerMixin
+from sqlalchemy_serializer.serializer import Serializer
+
+from .models import Base
+
+
+def test_is_valid_callable_with_varargs():
+    """Test that functions with *args are not valid callables."""
+
+    def func_with_args(*args):
+        return args
+
+    assert Serializer.is_valid_callable(func_with_args) is False
+
+
+def test_is_valid_callable_with_varkw():
+    """Test that functions with **kwargs are not valid callables."""
+
+    def func_with_kwargs(**kwargs):
+        return kwargs
+
+    assert Serializer.is_valid_callable(func_with_kwargs) is False
+
+
+def test_is_valid_callable_with_both_varargs_and_varkw():
+    """Test that functions with both *args and **kwargs are not valid callables."""
+
+    def func_with_both(*args, **kwargs):
+        return args, kwargs
+
+    assert Serializer.is_valid_callable(func_with_both) is False
+
+
+def test_is_valid_callable_method_without_self():
+    """Test that MethodType without 'self' as first arg is not valid callable."""
+
+    class ModelWithClassMethod(Base, SerializerMixin):
+        __tablename__ = "model_with_classmethod"
+        serialize_only = ()
+        serialize_rules = ()
+
+        id = sa.Column(sa.Integer, primary_key=True)
+        string = sa.Column(sa.String(256), default="test")
+
+        @classmethod
+        def class_method(cls) -> str:
+            return "result"
+
+    model = ModelWithClassMethod(id=1, string="test")
+    method = model.class_method
+
+    # Verify it's a MethodType
+    assert isinstance(method, MethodType)
+
+    # Should return False because first arg is 'cls', not 'self'
+    assert Serializer.is_valid_callable(method) is False
+
+
+def test_is_valid_callable_method_with_empty_args():
+    """Test that MethodType with no args (not even self) is not valid callable."""
+
+    # Create a function with no args
+    def func_no_args():
+        return "result"
+
+    # Manually create a MethodType bound to an object
+    # This simulates a method with no args
+    # (which shouldn't happen in normal Python, but tests the edge case)
+    class DummyObj:
+        pass
+
+    obj = DummyObj()
+    # Bind the function as a method
+    method = MethodType(func_no_args, obj)
+
+    # Verify it's a MethodType
+    assert isinstance(method, MethodType)
+
+    # Verify it has no args
+    # inspect.getfullargspec on bound method returns underlying function's args
+    spec = inspect.getfullargspec(method)
+    assert not spec.args
+
+    # Should return False because no args
+    assert Serializer.is_valid_callable(method) is False

tests/test_tree.py

@@ -124,3 +124,14 @@ def test_merge_trees():
     assert leaf.is_greedy
     assert leaf.to_include
     assert leaf.to_exclude is None
+
+
+def test_tree_repr():
+    tree = Tree(to_include=True, to_exclude=False, is_greedy=True)
+    tree["key1"] = Tree(to_include=True, to_exclude=False, is_greedy=True)
+    tree["key1"]["key2"] = Tree(to_include=True, to_exclude=False, is_greedy=True)
+    assert repr(tree) == (
+        "Tree(to_include=True, to_exclude=False, is_greedy=True)[\n"
+        "key1: Tree(to_include=True, to_exclude=False, is_greedy=True)[\n"
+        "  key2: Tree(to_include=True, to_exclude=False, is_greedy=True)[]]]"
+    )