Merge pull request #63 from lmignon/finx-multi-inheritance

Finx multi inheritance

Author: SVilgelm

marshmallow_objects/models.py

@@ -54,13 +54,17 @@ def __new__(mcs, name, parents, dct):
                                                        'handle_error'):
                 schema_fields[key] = value
 
-        parent_schema = cls.__schema_class__ or marshmallow.Schema
+        parent_schemas = []
         if parents:
             for parent in parents:
                 if issubclass(parent, Model):
-                    parent_schema = parent.__schema_class__
-                    break
-        schema_class = type(name + 'Schema', (parent_schema, ), schema_fields)
+                    parent_schemas.append(parent.__schema_class__)
+        parent_schemas = (
+                parent_schemas
+                or [cls.__schema_class__ or marshmallow.Schema]
+        )
+        schema_class = type(
+            name + 'Schema', tuple(parent_schemas), schema_fields)
         cls.__schema_class__ = schema_class
 
         return cls

tests/test_models.py

@@ -54,6 +54,10 @@ class C(marshmallow.Model):
     a = marshmallow.NestedModel(A, many=True)
 
 
+class MultiInheritance(A, B, C):
+    pass
+
+
 def serialize_context_field(obj, context=None):
     return obj.test_field == context['value']
 
@@ -80,27 +84,43 @@ def test_schema_name(self):
 
     def test_schema_class(self):
         assert issubclass(A.__schema_class__, marshmallow.Schema)
+        assert issubclass(
+            MultiInheritance.__schema_class__, marshmallow.Schema)
 
     def test_model_class(self):
         assert issubclass(A.__schema_class__.__model_class__,
                           marshmallow.Model)
+        assert issubclass(
+            MultiInheritance.__schema_class__.__model_class__,
+            marshmallow.Model)
 
     def test_tag_processor(self):
         assert hasattr(A.__schema_class__, 'set_tag_field')
+        assert hasattr(MultiInheritance.__schema_class__, 'set_tag_field')
 
     def test_meta(self):
         assert hasattr(A.__schema_class__, 'Meta')
         self.assertEqual(id(A.Meta), id(A.__schema_class__.Meta))
         assert not hasattr(B, 'Meta')
         assert hasattr(B.__schema_class__, 'Meta')
+        self.assertEqual(
+            id(MultiInheritance.Meta),
+            id(MultiInheritance.__schema_class__.Meta))
+        assert hasattr(MultiInheritance.__schema_class__, 'Meta')
 
     def test_on_bind_filed(self):
         self.assertEqual(
             id(A.on_bind_field), id(A.__schema_class__.on_bind_field))
+        self.assertEqual(
+            id(MultiInheritance.on_bind_field),
+            id(MultiInheritance.__schema_class__.on_bind_field))
 
     def test_handle_error(self):
         self.assertEqual(
             id(A.handle_error), id(A.__schema_class__.handle_error))
+        self.assertEqual(
+            id(MultiInheritance.handle_error),
+            id(MultiInheritance.__schema_class__.handle_error))
 
 
 class TestModel(unittest.TestCase):