def test_class_with_missing_attribute(self): @pyckson class Foo: def __init__(self, bar: str): self.bar = bar with self.assertRaises(ValueError): serialize(Foo(None))
def test_should_serialize_decimal(): class Foo: def __init__(self, x: Decimal): self.x = x pi = '3.141592653589793238462643383279502884197' assert serialize(Foo(Decimal(pi))) == {'x': pi}
def test_without_annotation(self): class Foo: def __init__(self, bar: List[str]): self.bar = bar result = serialize(Foo(['a', 'b'])) self.assertEqual(result, {'bar': ['a', 'b']})
def test_serialize_old_dict(self): class Foo: def __init__(self, foo: dict): self.foo = foo result = serialize(Foo({'a': 1, 'b': 2})) self.assertEqual(result, {'foo': {'a': 1, 'b': 2}})
def test_class_with_optional_param_type(self): class Foo: def __init__(self, bar: Optional[str]): self.bar = bar result = serialize(Foo('a')) self.assertEqual(result, {'bar': 'a'})
def test_serialize_double_list(self): class Foo: def __init__(self, bar: List[List[str]]): self.bar = bar result = serialize(Foo([['a', 'b'], ['c']])) self.assertEqual(result, {'bar': [['a', 'b'], ['c']]})
def test_class_with_generic_list(self): @pyckson class Foo: def __init__(self, bar: List[str]): self.bar = bar result = serialize(Foo(['a', 'b'])) self.assertEqual(result, {'bar': ['a', 'b']})
def test_should_be_able_to_serialize_lists(self): class Foo: def __init__(self, a: int): self.a = a result = serialize([Foo(1), Foo(2)]) self.assertEqual(result, [{'a': 1}, {'a': 2}])
def test_class_with_optional_param_type_absent(self): class Foo: def __init__(self, bar: Optional[str]): self.bar = bar result = serialize(Foo(None)) self.assertEqual(result, {})
def test_simple_class(self): @pyckson class Foo: def __init__(self, bar: str): self.bar = bar result = serialize(Foo('bar')) self.assertEqual(result, {'bar': 'bar'})
def test_no_camel_case(self): @pyckson @no_camel_case class Foo: def __init__(self, foo_bar: str): self.foo_bar = foo_bar foo = Foo('foo') self.assertEqual(serialize(foo), {'foo_bar': 'foo'})
def test_no_camel_case(self): @pyckson @no_camel_case class Foo: def __init__(self, foo_bar: str): self.foo_bar = foo_bar foo = Foo("foo") self.assertEqual(serialize(foo), {"foo_bar": "foo"})
def test_serialize_set_as_list(self): class Foo: def __init__(self, x: Set[int]): self.x = x result = serialize(Foo({1, 2})) # because of unknown ordering self.assertSetEqual(set(result['x']), {1, 2})
def test_with_date(self): @pyckson class Foo: def __init__(self, x: datetime): self.x = x date = datetime(2016, 2, 18, 10, 59, 0) result = serialize(Foo(date)) self.assertEqual(result, {'x': date})
def test_with_bytes(self): @pyckson class Foo: def __init__(self, x: bytes): self.x = x data = b"bar" result = serialize(Foo(data)) self.assertEqual(result, {'x': data})
def test_class_with_list(self): @pyckson @listtype('bar', str) class Foo: def __init__(self, bar: list): self.bar = bar result = serialize(Foo(['a', 'b'])) self.assertEqual(result, {'bar': ['a', 'b']})
def test_class_with_optional_attribute(self): @pyckson class Foo: def __init__(self, a: int, b: str = None): self.a = a self.b = b result = serialize(Foo(42)) self.assertEqual(result, {'a': 42})
def test_should_serialize_empty_mandatory_list(self): @pyckson @listtype('bar', str) class Foo: def __init__(self, bar: list): self.bar = bar result = serialize(Foo([])) self.assertEqual(result, {'bar': []})
def test_rename_and_no_camel_case(self): @pyckson @rename(foo='_foo') @no_camel_case class Foo: def __init__(self, foo: str, bar_bar: str): self.foo = foo self.bar_bar = bar_bar foo = Foo('foo', 'bar') self.assertEqual(serialize(foo), {'_foo': 'foo', 'bar_bar': 'bar'})
def test_use_explicit_nulls(self): @pyckson @explicit_nulls class Foo: def __init__(self, a: str = None): self.a = a result = serialize(Foo(a=None)) self.assertEqual(result, {'a': None}) self.assertEqual(dumps(result), '{"a": null}')
def test_rename_and_no_camel_case(self): @pyckson @rename(foo="_foo") @no_camel_case class Foo: def __init__(self, foo: str, bar_bar: str): self.foo = foo self.bar_bar = bar_bar foo = Foo("foo", "bar") self.assertEqual(serialize(foo), {"_foo": "foo", "bar_bar": "bar"})
def test_class_with_legacy_set(self): @pyckson @settype('bar', str) class Foo: def __init__(self, bar: set): self.bar = bar result = serialize(Foo({'a', 'b'})) # because of unknown ordering self.assertSetEqual(set(result['bar']), {'a', 'b'})
def test_with_unicode(self): class FakeString(str): pass @pyckson class Foo: def __init__(self, x: str): self.x = x result = serialize(Foo(FakeString('foo'))) self.assertEqual(result, {'x': 'foo'})
def test_should_be_able_to_serialize_typing_dicts(self): class Foo: def __init__(self, a: int): self.a = a class Bar: def __init__(self, b: Dict[str, Foo]): self.b = b result = serialize(Bar({'1': Foo(1), '2': Foo(2)})) self.assertEqual(result, {'b': {'1': {'a': 1}, '2': {'a': 2}}})
def test_custom_name_rule(self): def my_rule(python_name): return 'foo' + python_name @pyckson @namerule(my_rule) class Foo: def __init__(self, bar: str): self.bar = bar foo = Foo('foo') self.assertEqual(serialize(foo), {'foobar': 'foo'})
def test_custom_name_rule(self): def my_rule(python_name): return "foo" + python_name @pyckson @namerule(my_rule) class Foo: def __init__(self, bar: str): self.bar = bar foo = Foo("foo") self.assertEqual(serialize(foo), {"foobar": "foo"})
def test_class_with_optional_object_param_type(self): class Foo: def __init__(self, arg1: str): self.arg1 = arg1 class Bar: def __init__(self, a_foo: Optional[Foo]): self.a_foo = a_foo result = serialize(Bar(Foo("foo"))) self.assertEqual(result, {'aFoo': {'arg1': 'foo'}})
def test_rename_rule(self): @pyckson @rename(foo="_foo", bar="bar_") class Foo: def __init__(self, foo: str, bar: str): self.foo = foo self.bar = bar foo = Foo("foo", "bar") self.assertEqual(serialize(foo), {"_foo": "foo", "bar_": "bar"}) foo = parse(Foo, {"_foo": "foo", "bar_": "bar"}) self.assertEqual(foo.foo, "foo") self.assertEqual(foo.bar, "bar")
def test_rename_rule(self): @pyckson @rename(foo='_foo', bar='bar_') class Foo: def __init__(self, foo: str, bar: str): self.foo = foo self.bar = bar foo = Foo('foo', 'bar') self.assertEqual(serialize(foo), {'_foo': 'foo', 'bar_': 'bar'}) foo = parse(Foo, {'_foo': 'foo', 'bar_': 'bar'}) self.assertEqual(foo.foo, 'foo') self.assertEqual(foo.bar, 'bar')
def test_class_with_generic_object_list(self): @pyckson class Bar: def __init__(self, x: str): self.x = x @pyckson class Foo: def __init__(self, bar: List[Bar]): self.bar = bar result = serialize(Foo([Bar('a'), Bar('b')])) self.assertEqual(result, {'bar': [{'x': 'a'}, {'x': 'b'}]})
def test_should_be_able_to_serialize_union_type(self): class X: def __init__(self, x: str): self.x = x class Y: def __init__(self, y: str): self.y = y class Foo: def __init__(self, foo: Union[X, Y]): self.foo = foo assert serialize(Foo(X('a'))) == {'foo': {'x': 'a'}}
def test_custom_serializer(self): class Foo: def __init__(self, bar): self.bar = bar class FooSerializer(Serializer): def serialize(self, obj: Foo) -> dict: return {'toto': obj.bar} custom_serializer(FooSerializer)(Foo) result = serialize(Foo(42)) self.assertEqual(result, {'toto': 42})
def test_should_serialize_list_with_unresolved_type(self): @pyckson class Bar: def __init__(self, x: str): self.x = x @pyckson @listtype('bar', Bar) class Foo: def __init__(self, bar: list): self.bar = bar result = serialize(Foo([Bar('y')])) self.assertEqual(result, {'bar': [{'x': 'y'}]})
def test_custom_serializer_on_param(self): class Bar: def __init__(self): pass class BarSerializer(Serializer): def serialize(self, obj: Bar): return 42 class Foo: def __init__(self, bar: Bar): self.bar = bar custom_serializer(BarSerializer)(Bar) result = serialize(Foo(Bar())) self.assertEqual(result, {'bar': 42})