Add a strict mode to Integer

This would disallow float's from being accepted and truncated

colander/__init__.py

@@ -1432,6 +1432,18 @@ class Integer(Number):
 
     num = int
 
+    def __init__(self, strict=False):
+        if strict:
+
+            def _strict_int(val):
+                if not float(val).is_integer():
+                    raise ValueError("Value is not an Integer")
+                return int(val)
+
+            self.num = _strict_int
+
+        super(Integer, self).__init__()
+
 
 Int = Integer
 

colander/tests/test_colander.py

@@ -1730,10 +1730,10 @@ def test_serialize_encoding_with_non_string_type(self):
 
 
 class TestInteger(unittest.TestCase):
-    def _makeOne(self):
+    def _makeOne(self, strict=False):
         from colander import Integer
 
-        return Integer()
+        return Integer(strict=strict)
 
     def test_alias(self):
         from colander import Int
@@ -1802,6 +1802,34 @@ def test_serialize_zero(self):
         result = typ.serialize(node, val)
         self.assertEqual(result, '0')
 
+    def test_serialize_strict_float(self):
+        val = 1.2
+        node = DummySchemaNode(None)
+        typ = self._makeOne(strict=True)
+        e = invalid_exc(typ.serialize, node, val)
+        self.assertTrue(e.msg)
+
+    def test_serialize_strict_int(self):
+        val = 1
+        node = DummySchemaNode(None)
+        typ = self._makeOne(strict=True)
+        result = typ.serialize(node, val)
+        self.assertEqual(result, '1')
+
+    def test_deserialize_strict(self):
+        val = '58'
+        node = DummySchemaNode(None)
+        typ = self._makeOne(strict=True)
+        result = typ.deserialize(node, val)
+        self.assertEqual(result, 58)
+
+    def test_serialize_truncates(self):
+        val = 1.4
+        node = DummySchemaNode(None)
+        typ = self._makeOne(strict=False)
+        result = typ.serialize(node, val)
+        self.assertEqual(result, '1')
+
 
 class TestFloat(unittest.TestCase):
     def _makeOne(self):