Added much better json encoding and decoding tests, and fixed bugs caught.

braincore · braincore · commit 2fba016502fa · 2014-12-12T13:04:02.000-08:00
diff --git a/babelapi/generator/target/python/babel_data_types.py b/babelapi/generator/target/python/babel_data_types.py
@@ -94,8 +94,8 @@ def __init__(self, min_value=None, max_value=None):
 
     def validate(self, val):
         if not isinstance(val, numbers.Integral):
-            raise ValidationError('%r is of type %r and is not a valid integer type'
-                                  % (val, type(val)))
+            raise ValidationError('expected integer, got %s'
+                                  % generic_type_name(val))
         elif not (self.minimum <= val <= self.maximum):
             raise ValidationError('%d is not within range [%d, %d]'
                                   % (val, self.minimum, self.maximum))
diff --git a/babelapi/generator/target/python/babel_serializers.py b/babelapi/generator/target/python/babel_serializers.py
@@ -99,12 +99,9 @@ def _encode_helper(cls, data_type, obj, validate_primitives=True):
             if field_data_type:
                 if isinstance(field_data_type, (dt.Any, dt.Symbol)):
                     return obj._tag
-                elif isinstance(field_data_type, dt.PrimitiveType):
-                    val = getattr(obj, obj._tag)
-                    return cls._make_json_friendly(field_data_type, val)
                 else:
                     val = getattr(obj, obj._tag)
-                    return {obj._tag: cls._encode_helper(field_data_type, val)}
+                    return {obj._tag: cls._encode_helper(field_data_type, val, False)}
             else:
                 return obj._tag
         else:
diff --git a/test/test_python_gen.py b/test/test_python_gen.py
@@ -104,6 +104,43 @@ def test_json_encoder(self):
         b = '\xff' * 5
         self.assertEqual(JsonEncoder.encode(dt.Binary(), b), json.dumps(base64.b64encode(b)))
 
+    def test_json_encoder_union(self):
+        class S(object):
+            _field_names_ = {'f'}
+            _fields_ = [('f', dt.String())]
+        class U(object):
+            _fields_ = {'a': dt.Int64(),
+                        'b': dt.Symbol(),
+                        'c': dt.Struct(S),
+                        'd': dt.List(dt.Int64())}
+
+        # Test primitive variant
+        u = U()
+        u._tag = 'a'
+        u.a = 64
+        self.assertEqual(JsonEncoder.encode(dt.Union(U), u), json.dumps({'a': 64}))
+
+        # Test symbol variant
+        u = U()
+        u._tag = 'b'
+        self.assertEqual(JsonEncoder.encode(dt.Union(U), u), json.dumps('b'))
+
+        # Test struct variant
+        u = U()
+        u._tag = 'c'
+        u.c = S()
+        u.c.f = 'hello'
+        self.assertEqual(JsonEncoder.encode(dt.Union(U), u), json.dumps({'c': {'f': 'hello'}}))
+
+        # Test list variant
+        u = U()
+        u._tag = 'd'
+        u.d = [1, 2, 3, 'a']
+        # lists should be re-validated during serialization
+        self.assertRaises(dt.ValidationError, lambda: JsonEncoder.encode(dt.Union(U), u))
+        u.d = [1, 2, 3, 4]
+        self.assertEqual(JsonEncoder.encode(dt.Union(U), u), json.dumps({'d': u.d}))
+
     def test_json_decoder(self):
         self.assertEqual(JsonDecoder.decode(dt.String(), json.dumps('abc')), 'abc')
         self.assertEqual(JsonDecoder.decode(dt.UInt32(), json.dumps(123)), 123)
@@ -115,3 +152,36 @@ def test_json_decoder(self):
                          now)
         b = '\xff' * 5
         self.assertEqual(JsonDecoder.decode(dt.Binary(), json.dumps(base64.b64encode(b))), b)
+
+    def test_json_decoder_union(self):
+        class S(object):
+            _field_names_ = {'f'}
+            _fields_ = [('f', dt.String())]
+        class U(object):
+            _fields_ = {'a': dt.Int64(),
+                        'b': dt.Symbol(),
+                        'c': dt.Struct(S),
+                        'd': dt.List(dt.Int64())}
+            _tag = None
+            def set_b(self):
+                self._tag = 'b'
+
+        # Test primitive variant
+        u = JsonDecoder.decode(dt.Union(U), json.dumps({'a': 64}))
+        self.assertEqual(u.a, 64)
+
+        # Test symbol variant
+        u = JsonDecoder.decode(dt.Union(U), json.dumps('b'))
+        self.assertEqual(u._tag, 'b')
+
+        # Test struct variant
+        u = JsonDecoder.decode(dt.Union(U), json.dumps({'c': {'f': 'hello'}}))
+        self.assertEqual(u.c.f, 'hello')
+
+        # Test list variant
+        l = [1, 2, 3, 4]
+        u = JsonDecoder.decode(dt.Union(U), json.dumps({'d': l}))
+        self.assertEqual(u.d, l)
+
+        # Raises if unknown tag
+        self.assertRaises(dt.ValidationError, lambda: JsonDecoder.decode(dt.Union(U), json.dumps('z')))
