def test_map_key_types(self):
class A(Unimodel):
a = Field(Map(UTF8, Int))
b = Field(Map(Binary, Int))
c = Field(Map(Int8, Int))
d = Field(Map(Int, Int))
e = Field(Map(Enum({1: "one", 2: "two"}), Int))
data = A(
a={"a": 1},
b={bin(173): 1},
c={1: 1},
d={2 ** 40: 1},
e={2: 1})
serializer = JSONSerializer()
s = serializer.serialize(data)
read_data = serializer.deserialize(A, s)
self.assertEquals(data, read_data)
class B(Unimodel):
a = Field(Map(Double, Int))
exc = None
try:
print serializer.serialize(B(a={2.333: 1}))
except Exception as exc:
pass
def test_serialize_all_types_data(self):
""" serialize a complex recursive datatype into JSON """
serializer = JSONSerializer()
for ix in xrange(0, len(all_types_data)):
s = serializer.serialize(all_types_data[ix])
d = serializer.deserialize(all_types_data[ix].__class__, s)
self.assertEquals(d, all_types_data[ix])
def test_validate_recursive_schema(self):
# based on http://sacharya.com/validating-json-using-python-jsonschema/
schema_writer = JSONSchemaWriter()
schema = schema_writer.get_schema_ast(TreeNode)
serializer = JSONSerializer()
json_data = json.loads(serializer.serialize(tree_data))
jsonschema.validate(json_data, schema)
def test_serialize_tree_data(self):
""" serialize a complex recursive datatype into JSON """
pre_flattened = flatten(tree_data)
serializer = JSONSerializer()
s = serializer.serialize(tree_data)
d = serializer.deserialize(TreeNode, s)
self.assertEquals(d.__class__, TreeNode)
post_flattened = flatten(d)
def test_validate_all_types(self):
# based on http://sacharya.com/validating-json-using-python-jsonschema/
schema_writer = JSONSchemaWriter()
schema = schema_writer.get_schema_ast(AllTypes)
serializer = JSONSerializer()
for ix in xrange(0, len(all_types_data)):
json_data = json.loads(serializer.serialize(all_types_data[ix]))
jsonschema.validate(json_data, schema)
def test_simple_struct(self):
schema_writer = JSONSchemaWriter()
schema = schema_writer.get_schema_ast(TreeNode)
generator = JSONSchemaModelGenerator('untitled', schema)
serializer = JSONSerializer()
json_data = json.loads(
serializer.serialize(
generator.generate_model_schema()))
def test_custom_field_names(self):
NAME = "/-/"
class A(Unimodel):
a = Field(Map(UTF8, Int), metadata=Metadata(
backend_data={'json': {MDK_FIELD_NAME: NAME}}))
serializer = JSONSerializer()
data = A(a={"a": 1})
s = serializer.serialize(data)
parsed_json = json.loads(s)
self.assertTrue(NAME in parsed_json)
self.assertEquals(data, serializer.deserialize(A, s))
def test_read_validation(self):
class A(Unimodel):
u = Field(List(Int))
json_str = '{"u": ["a", "b", "c"]}'
serializer = JSONSerializer()
exc = None
try:
d = serializer.deserialize(A, json_str)
except Exception as exc:
pass
self.assertTrue(exc is not None)
self.assertEquals(type(exc), JSONValidationException)
self.assertEquals(exc.context.current_path(), "u[0]")
self.assertEquals(exc.context.current_value(), "a")
def test_enum_serialize(self):
""" serialize a complex recursive datatype into JSON """
class A(Unimodel):
f = Field(Enum({1: "one", 2: "two"}))
serializer = JSONSerializer()
s = serializer.serialize(A(f=1))
parsed_json = json.loads(s)
self.assertEquals(parsed_json['f'], "one")
d = serializer.deserialize(A, s)
self.assertEquals(d.f, 1)
exc = None
try:
serializer.serialize(A(f=33))
except Exception as exc:
pass
self.assertTrue(isinstance(exc, ValueTypeException))
def test_unknown_fields(self):
class A(Unimodel):
u = Field(List(UTF8))
json_str = '{"u": ["a", "b", "c"], "x": 1}'
serializer = JSONSerializer()
# by default, unknown fields are skipped
d = serializer.deserialize(A, json_str)
exc = None
try:
serializer = JSONSerializer(skip_unknown_fields=False)
d = serializer.deserialize(A, json_str)
except Exception as exc:
pass
self.assertTrue(exc is not None)
self.assertEquals(type(exc), JSONValidationException)
self.assertEquals(exc.context.current_path(), "")
self.assertTrue("unknown fields" in str(exc))
def test_unicode_and_binary(self):
""" serialize unicode and binary data """
class ExampleClass(Unimodel):
u = Field(UTF8, required=True)
s = Field(Binary)
test_string1 = unichr(40960)
test_string2 = b"alma"
data = ExampleClass(u=test_string1, s=test_string2)
serializer = JSONSerializer()
s = serializer.serialize(data)
json_data = json.loads(s)
d = serializer.deserialize(ExampleClass, s)
self.assertEquals(d.s, data.s)
self.assertEquals(d.u, data.u)
self.assertEquals(type(d.u), unicode)
self.assertNotEquals(d.s, json_data['s'])
def test_unboxed_struct(self):
class Unboxed(Unimodel):
a = Field(Int)
b = Field(Int)
class Parent(Unimodel):
a = Field(
Struct(Unboxed),
metadata=Metadata(
backend_data={'json': {MDK_TYPE_STRUCT_UNBOXED: True}}))
c = Field(Int)
serializer = JSONSerializer()
data = Parent(a=Unboxed(a=1, b=2), c=3)
s = serializer.serialize(data)
parsed_json = json.loads(s)
self.assertEquals(sorted(parsed_json.keys()), ["a", "b", "c"])
self.assertEquals(data, serializer.deserialize(Parent, s))
def test_swagger_struct(self):
with open("/Users/neumark/git/swagger-spec/schemas/v2.0/schema.json", "r") as f:
schema = json.loads(f.read())
schema_name = 'swagger'
generator = JSONSchemaModelGenerator(schema_name, schema)
serializer = JSONSerializer()
model_schema = generator.generate_model_schema()
#model_schema.validate()
json_data = json.loads(serializer.serialize(model_schema))
output_json = json.dumps(
json_data,
sort_keys=True,
indent=4,
separators=(',', ': '))
#print output_json
python_source = SchemaCompiler(model_schema).generate_model_classes()
