Issue #22: Use converter instead of strict mode.

Author: boonya

domain_models/fields.py

@@ -41,8 +41,9 @@ 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.")
@@ -59,65 +60,59 @@ def set_value(self, model, value):
             raise AttributeError("This field is required.")
 
         if value is not None:
-            value = self._converter(value)
-        setattr(model, self.storage_name, value)
-
-    def is_valid_type(self, value):
-        """Check whether the value is valid type.
+            value = self.converter(value)
 
-        :param value:
-        """
-        return self._converter(value) == value
+        setattr(model, self.storage_name, value)
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         return value
 
 
 class Bool(Field):
     """Bool field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         return bool(value)
 
 
 class Int(Field):
     """Int field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         return int(value)
 
 
 class Float(Field):
     """Float field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         return float(value)
 
 
 class String(Field):
     """String field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         return str(value)
 
 
 class Binary(Field):
     """Binary field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         return six.binary_type(value)
 
 
 class Date(Field):
     """Date field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         if not isinstance(value, datetime.date):
             raise TypeError('{0} is not valid date'.format(value))
@@ -127,7 +122,7 @@ def _converter(self, value):
 class DateTime(Field):
     """Date and time field."""
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         if not isinstance(value, datetime.datetime):
             raise TypeError('{0} is not valid date and time')
@@ -143,7 +138,7 @@ def __init__(self, related_model_cls, default=None, required=False):
 
         self.related_model_cls = related_model_cls
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         if not isinstance(value, self.related_model_cls):
             raise TypeError('{0} is not valid model instance, instance of '
@@ -160,7 +155,7 @@ def __init__(self, related_model_cls, default=None, required=False):
         super(Collection, self).__init__(default=default, required=required)
         self.related_model_cls = related_model_cls
 
-    def _converter(self, value):
+    def converter(self, value):
         """Convert raw input value of the field."""
         if type(value) is not self.related_model_cls.Collection:
             value = self.related_model_cls.Collection(value)

domain_models/models.py

@@ -192,20 +192,25 @@ def get(self, field_name, default=None):
         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 `AttributeError` if `default` is not the same type
-        as field value.
+        It will raise `AttributeError` 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:
         """
-        value = getattr(self, field_name)
+        if not hasattr(self, field_name):
+            raise AttributeError(
+                "Model doesn't have a field '{name}'".format(name=field_name))
 
-        if default is not None and value is None:
+        if default is not None:
             field = dict((field.name, field) for field in
                          self.__class__.__fields__).get(field_name)
-            if not field.is_valid_type(default):
+            try:
+                default = field.converter(default)
+            except (TypeError, ValueError):
                 raise AttributeError(
-                    "default must be the same type as the field.")
+                    "default can not be converted to right type value")
 
-        return value if value else default
+        value = getattr(self, field_name)
+        return value if value is not None else 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,38 +168,155 @@ class Model2(models.DomainModel):
 
                 field = Model1.field
 
-    def test_get_method(self):
-        mock_id = 2
-        mock_name = 'foobar'
+    def test_get_method_on_undefined(self):
+        """Test method get of Model."""
 
-        class SomeModel(models.DomainModel):
-            """Test domain model."""
-            id = fields.Int()
-            name = fields.String()
-            string = fields.String()
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Int()
+
+        model = Model()
 
-        model = SomeModel(id=mock_id, name=mock_name)
+        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]
 
-        self.assertEqual(model.get('id'), mock_id)
-        self.assertEqual(model.get('id', 0), mock_id)
-        self.assertEqual(model.get('id', 123), mock_id)
+        class Model(models.DomainModel):
+            """Test model."""
+            field = fields.Int()
 
-        self.assertEqual(model.get('name'), mock_name)
-        self.assertEqual(model.get('name', ''), mock_name)
-        self.assertEqual(model.get('name', 'another-name'), mock_name)
+        model = Model(field=2)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), 2)
 
-        self.assertEqual(model.get('string'), None)
-        self.assertEqual(model.get('string', ''), '')
-        self.assertEqual(model.get('string', 'not-empty'), 'not-empty')
+        model = Model()
+        self.assertEqual(model.get('field'), None)
+        for value in valid_defaults:
+            self.assertEqual(model.get('field', default=value), int(value))
 
-        string = model.get('string', '')
-        self.assertEqual(string, '')
+        for value in ['', u'baz']:
+            with self.assertRaises(AttributeError):
+                model.get('field', value)
+                self.fail("Failed with {value}".format(value=str(value)))
 
-        with self.assertRaises(AttributeError):
-            model.get('unknown')
+    def test_get_method_on_string(self):
+        """Test method get on String of Model."""
+        valid_defaults = ['', 'baz', u'baz', False, True, 1, 2.3]
 
-        with self.assertRaises(AttributeError):
-            model.get('string', 0)
+        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', datetime]:
+            with self.assertRaises(AttributeError):
+                model.get('field', value)
+                self.fail("Failed with {value}".format(value=str(value)))
+
+    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(AttributeError):
+                model.get('field', value)
+                self.fail("Failed with {value}".format(value=str(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(AttributeError):
+                model.get('field', value)
+                self.fail("Failed with {value}".format(value=str(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):