Merge remote-tracking branch 'origin/22-get_method_of_model'

Author: rmk135

domain_models/fields.py

@@ -41,17 +41,26 @@ def bind_model_cls(self, model_cls):
 
     def init_model(self, model, value):
         """Init model with field."""
-        if value is None:
+        if value is None and self.default is not None:
             value = self.default() if callable(self.default) else self.default
+            value = self._converter(value)
 
         if value is None and self.required:
             raise AttributeError("This field is required.")
 
         setattr(model, self.storage_name, value)
 
-    def get_value(self, model):
-        """Return field's value."""
-        return getattr(model, self.storage_name)
+    def get_value(self, model, default=None):
+        """Return field's value.
+
+        :param DomainModel model:
+        :param mixed default:
+        """
+        if default is not None:
+            default = self._converter(default)
+
+        value = getattr(model, self.storage_name)
+        return value if value is not None else default
 
     def set_value(self, model, value):
         """Set field's value."""
@@ -60,6 +69,7 @@ def set_value(self, model, value):
 
         if value is not None:
             value = self._converter(value)
+
         setattr(model, self.storage_name, value)
 
     def _converter(self, value):

domain_models/models.py

@@ -63,8 +63,8 @@ def prepare_fields_attribute(attribute_name, attributes, class_name):
     @staticmethod
     def bind_fields_to_model_cls(cls, model_fields):
         """Bind fields to model class."""
-        return tuple(field.bind_model_cls(cls)
-                     for field in model_fields)
+        return dict(
+            (field.name, field.bind_model_cls(cls)) for field in model_fields)
 
     @staticmethod
     def bind_collection_to_model_cls(cls):
@@ -92,9 +92,9 @@ class DomainModel(object):
 
     .. py:attribute:: __fields__
 
-        Tuple of all model fields.
+        Dictionary of all model fields.
 
-        :type: tuple[fields.Field]
+        :type: dict[str, fields.Field]
 
     .. py:attribute:: __unique_key__
 
@@ -111,15 +111,15 @@ class DomainModel(object):
 
     Collection = collections.Collection
 
-    __fields__ = tuple()
+    __fields__ = dict()
     __view_key__ = tuple()
     __unique_key__ = tuple()
     __slots_optimization__ = True
 
     def __init__(self, **kwargs):
         """Initializer."""
-        for field in self.__class__.__fields__:
-            field.init_model(self, kwargs.get(field.name))
+        for name, field in six.iteritems(self.__class__.__fields__):
+            field.init_model(self, kwargs.get(name))
         super(DomainModel, self).__init__()
 
     def __eq__(self, other):
@@ -164,14 +164,16 @@ def __repr__(self):
         """Return Pythonic representation of domain model."""
         return '{module}.{cls}({fields_values})'.format(
             module=self.__class__.__module__, cls=self.__class__.__name__,
-            fields_values=', '.join('='.join((field.name,
-                                              repr(field.get_value(self))))
-                                    for field in self.__class__.__fields__))
+            fields_values=', '.join(
+                '='.join((name, repr(field.get_value(self))))
+                for name, field in
+                six.iteritems(self.__class__.__fields__)))
 
     def __str__(self):
         """Return string representation of domain model."""
         if not self.__class__.__view_key__:
             return self.__repr__()
+
         return '{module}.{cls}({fields_values})'.format(
             module=self.__class__.__module__, cls=self.__class__.__name__,
             fields_values=', '.join('='.join((field.name,
@@ -181,5 +183,29 @@ def __str__(self):
     @property
     def __data__(self):
         """Read only dictionary of model fields/values."""
-        return dict((field.name, field.get_value(self))
-                    for field in self.__class__.__fields__)
+        return dict((name, field.get_value(self))
+                    for name, field in
+                    six.iteritems(self.__class__.__fields__))
+
+    def get(self, field_name, default=None):
+        """Return the value of the field.
+
+        Analogue for `dict.get()` python method.
+        `field_name` must be a string. If the string is the name of
+        one of the existent fields, the result is the value of that field.
+        For example, `model.get('foobar')` is equivalent to `model.foobar`.
+        If the filed does not have a value, `default` is returned if provided.
+        It will raise `TypeError` or `ValueError` if `default` can not be
+        converted to right type value.
+        If the field does not exist, `AttributeError` is raised as well.
+
+        :param string field_name:
+        :param mixed default:
+        """
+        try:
+            field = self.__class__.__fields__[field_name]
+        except KeyError:
+            raise AttributeError(
+                "Field {0} does not exist.".format(field_name))
+        else:
+            return field.get_value(self, default)

tests/test_models.py

@@ -1,7 +1,11 @@
 """Models tests."""
 
+import datetime
+
 import unittest2 as unittest
 
+import six
+
 from domain_models import models
 from domain_models import fields
 from domain_models import collections
@@ -164,6 +168,162 @@ class Model2(models.DomainModel):
 
                 field = Model1.field
 
+    def test_get_method_on_undefined(self):
+        """Test method get of Model."""
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Int()
+
+        model = Model()
+
+        with self.assertRaises(AttributeError):
+            model.get('undefined')
+
+    def test_get_method_on_int(self):
+        """Test method get on Int of Model."""
+        valid_defaults = [0, 3, 5.5, False, True]
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Int()
+
+        model = Model(field=2)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), 2)
+
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), int(value))
+
+        for value in ['', u'baz']:
+            with self.assertRaises(ValueError):
+                model.get('field', value)
+                self.fail("Failed with {0}".format(value))
+
+        with self.assertRaises(TypeError):
+            model.get('field', object())
+
+    def test_get_method_on_string(self):
+        """Test method get on String of Model."""
+        valid_defaults = ['', 'baz', u'baz', False, True, 1, 2.3]
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.String()
+
+        model = Model(field='foobar')
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), 'foobar')
+
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), str(value))
+
+    def test_get_method_on_bool(self):
+        """Test method get on Bool of Model."""
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Bool()
+
+        model = Model(field=True)
+        self.assertEqual(model.get('field'), True)
+        self.assertEqual(model.get('field', default=False), True)
+
+        model = Model(field=False)
+        self.assertEqual(model.get('field'), False)
+        self.assertEqual(model.get('field', default=True), False)
+
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        self.assertEqual(model.get('field', default=False), False)
+        self.assertEqual(model.get('field', default=True), True)
+
+    def test_get_method_on_float(self):
+        """Test method get on Float of Model."""
+        valid_defaults = [7.5, 7, '7.5', '7', 0, '0.0', .9, '.9', False, True]
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Float()
+
+        model = Model(field=5.5)
+        self.assertEqual(model.get('field'), 5.5)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), 5.5)
+
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), float(value))
+
+        for value in ['', 'baz', u'baz']:
+            with self.assertRaises(ValueError):
+                model.get('field', value)
+                self.fail("Failed with {0}".format(value))
+
+        with self.assertRaises(TypeError):
+            model.get('field', object())
+
+    def test_get_method_on_date(self):
+        """Test method get on Date of Model."""
+        once = datetime.date(year=1986, month=4, day=26)
+        today = datetime.date.today()
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Date()
+
+        model = Model(field=today)
+        self.assertEqual(model.get('field'), today)
+        self.assertEqual(model.get('field', once), today)
+
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        self.assertEqual(model.get('field', once), once)
+
+        for value in ['', 'baz', u'baz', 0, 3, 0.7, '.5', False, True]:
+            with self.assertRaises(TypeError):
+                model.get('field', value)
+                self.fail("Failed with {0}".format(value))
+
+    def test_get_method_on_datetime(self):
+        """Test method get on Date of Model."""
+        once = datetime.datetime(year=1986, month=4, day=26)
+        now = datetime.datetime.now()
+
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.DateTime()
+
+        model = Model(field=now)
+        self.assertEqual(model.get('field'), now)
+        self.assertEqual(model.get('field', once), now)
+
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        self.assertEqual(model.get('field', once), once)
+
+        for value in ['', 'baz', u'baz', 0, 3, 0.7, '.5', False, True]:
+            with self.assertRaises(TypeError):
+                model.get('field', value)
+                self.fail("Failed with {0}".format(value))
+
+    def test_get_method_on_binary(self):
+        """Test method get on Binary of Model."""
+        self.skipTest("Test is not implemented yet")
+
+    def test_get_method_on_model(self):
+        """Test method get on Model of Model."""
+        self.skipTest("Test is not implemented yet")
+
+    def test_get_method_on_collection(self):
+        """Test method get on Collection of Model."""
+        self.skipTest("Test is not implemented yet")
+
 
 class ModelReprTests(unittest.TestCase):
     """Tests for model Pythonic representation."""