async def _fbthrift__handler_expected_exception(self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize(module.lite_types._fbthrift_SimpleService_expected_exception_args, args, protocol) try: value = await self.expected_exception() return_struct = module.lite_types._fbthrift_SimpleService_expected_exception_result() except module.lite_types.SimpleException as e: return_struct = module.lite_types._fbthrift_SimpleService_expected_exception_result(se=e) buf = serialize_iobuf(return_struct, protocol) exp = PythonUserException('SimpleException', str(e), buf) raise exp return serialize_iobuf(return_struct, protocol)
def test_isset_Struct(self) -> None: to_serialize = OptionalFile(name="/dev/null", type=8) serialized = serialize_iobuf(to_serialize) file = deserialize(File, serialized) self.assertTrue(isset(file)["type"]) self.assertFalse(isset(file)["permissions"]) to_serialize = OptionalFile(name="/dev/null") serialized = serialize_iobuf(to_serialize) file = deserialize(File, serialized) self.assertEqual(file.type, Kind.REGULAR) self.assertFalse(isset(file)["type"])
def test_bad_enum_in_set_iter(self) -> None: x = deserialize( ColorGroups, serialize_iobuf(OptionalColorGroups(color_list=[1, 5, 0]))) for v in x.color_set: if v not in (Color.blue, Color.red): self.assertBadEnum(cast(BadEnum, v), Color, 5)
def test_map_type(self): s1 = MyStruct(intField=456, listOfIntField=[34, 59, 28], enumField=MyEnum.ONE) s2 = MyStruct(intField=123, listOfIntField=[12, 23], enumField=MyEnum.TWO) s3 = MapStruct( mapOfStrI32Field={ "a": 1, "b": 2, "c": 3, "d": 4 }, mapOfStrStructField={ "a": s1, "b": s2 }, mapOfStrEnumField={ "a": MyEnum.TWO, "c": MyEnum.ONE }, ) serialized = serialize_iobuf(s3) s4 = deserialize(MapStruct, serialized) self.assertEqual(s3, s4)
def test_serialize_deserialize(self) -> None: err = HardError(errortext="err", code=2) x = ValueOrError(error=err) serialized = serialize_iobuf(x) y = deserialize(ValueOrError, serialized) self.assertIsNot(x, y) self.assertEqual(x, y)
def test_default_values(self): s1 = StructWithDefaults() self.assertEqual(s1.intField, 42) self.assertEqual(s1.listOfIntField, (12, 34)) self.assertEqual( s1.simpleStructField, SimpleStruct(intField=678), ) self.assertEqual(s1.enumField, MyEnum.TWO) self.assertEqual(s1.setOfI32Field, {24, 65, 99}) self.assertEqual(s1.mapOfStrI32Field, {"a": 24, "b": 99}) self.assertEqual(s1.stringField, "awesome string") self.assertEqual(s1.binaryField, b"awesome bytes") serialized = serialize_iobuf(EmptyStruct()) # deserialize from empty payload s2 = deserialize(StructWithDefaults, serialized) self.assertEqual(s2.intField, 42) self.assertEqual(s2.listOfIntField, (12, 34)) self.assertEqual( s2.simpleStructField, SimpleStruct(intField=678), ) self.assertEqual(s2.enumField, MyEnum.TWO) self.assertEqual(s2.setOfI32Field, {24, 65, 99}) self.assertEqual(s2.mapOfStrI32Field, {"a": 24, "b": 99}) self.assertEqual(s2.stringField, "awesome string") self.assertEqual(s2.binaryField, b"awesome bytes")
def test_bad_enum_in_list_index(self) -> None: x = deserialize( ColorGroups, serialize_iobuf(OptionalColorGroups(color_list=[1, 5, 0]))) self.assertEqual(len(x.color_list), 3) self.assertEqual(x.color_list[0], Color.blue) self.assertBadEnum(cast(BadEnum, x.color_list[1]), Color, 5) self.assertEqual(x.color_list[2], Color.red)
def test_flag_enum_serialization_roundtrip(self) -> None: x = File(name="/dev/null", type=Kind.CHAR, permissions=Perm.read | Perm.write) y = deserialize(File, serialize_iobuf(x)) self.assertEqual(x, y) self.assertEqual(x.permissions, Perm.read | Perm.write) self.assertIsInstance(x.permissions, Perm)
def test_string_types(self): s1 = StringStruct( stringField="a string", binaryField=b"some bytes", ) serialized = serialize_iobuf(s1) s2 = deserialize(StringStruct, serialized) self.assertEqual(s2.stringField, "a string") self.assertEqual(s2.binaryField, b"some bytes")
async def _fbthrift__handler_sink( self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize( module.lite_types._fbthrift_MyService_sink_args, args, protocol) value = await self.sink(args_struct.sink, ) return_struct = module.lite_types._fbthrift_MyService_sink_result() return serialize_iobuf(return_struct, protocol)
async def _fbthrift__handler_check( self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize( py3lite_module_root.my.namespacing.extend.test.extend.lite_types. _fbthrift_ExtendTestService_check_args, args, protocol) value = await self.check(args_struct.struct1, ) return_struct = py3lite_module_root.my.namespacing.extend.test.extend.lite_types._fbthrift_ExtendTestService_check_result( success=value) return serialize_iobuf(return_struct, protocol)
async def _fbthrift__handler_getRandomData( self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize( module.lite_types._fbthrift_MyService_getRandomData_args, args, protocol) value = await self.getRandomData() return_struct = module.lite_types._fbthrift_MyService_getRandomData_result( success=value) return serialize_iobuf(return_struct, protocol)
async def _fbthrift__handler_getDataByKey1( self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize( module.lite_types. _fbthrift_DbMixedStackArguments_getDataByKey1_args, args, protocol) value = await self.getDataByKey1(args_struct.key, ) return_struct = module.lite_types._fbthrift_DbMixedStackArguments_getDataByKey1_result( success=value) return serialize_iobuf(return_struct, protocol)
async def _fbthrift__handler_deleteDataById( self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize( module.lite_types._fbthrift_MyService_deleteDataById_args, args, protocol) value = await self.deleteDataById(args_struct.id, ) return_struct = module.lite_types._fbthrift_MyService_deleteDataById_result( ) return serialize_iobuf(return_struct, protocol)
async def _fbthrift__handler_init( self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize( py3lite_module_root.my.namespacing.test.hsmodule.lite_types. _fbthrift_HsTestService_init_args, args, protocol) value = await self.init(args_struct.int1, ) return_struct = py3lite_module_root.my.namespacing.test.hsmodule.lite_types._fbthrift_HsTestService_init_result( success=value) return serialize_iobuf(return_struct, protocol)
def test_bad_enum_in_list_reverse(self) -> None: x = deserialize( ColorGroups, serialize_iobuf(OptionalColorGroups(color_list=[1, 5, 0]))) for idx, v in enumerate(reversed(x.color_list)): if idx == 0: self.assertEqual(v, Color.red) elif idx == 1: self.assertBadEnum(cast(BadEnum, v), Color, 5) else: self.assertEqual(v, Color.blue)
def test_simple_struct(self): s1 = MyStruct( intField=456, listOfIntField=[34, 59, 28], enumField=MyEnum.TWO, ) serialized = serialize_iobuf(s1) s2 = deserialize(MyStruct, serialized) self.assertIsNot(s1, s2) self.assertIs(s2.enumField, MyEnum.TWO) self.assertEqual(s1, s2) self.assertIsNone(s2.optionalField)
async def _fbthrift__handler_get500(self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize(module.lite_types._fbthrift_Raiser_get500_args, args, protocol) try: value = await self.get500() return_struct = module.lite_types._fbthrift_Raiser_get500_result(success=value) except module.lite_types.Fiery as e: return_struct = module.lite_types._fbthrift_Raiser_get500_result(f=e) buf = serialize_iobuf(return_struct, protocol) exp = PythonUserException('Fiery', str(e), buf) raise exp except module.lite_types.Banal as e: return_struct = module.lite_types._fbthrift_Raiser_get500_result(b=e) buf = serialize_iobuf(return_struct, protocol) exp = PythonUserException('Banal', str(e), buf) raise exp except module.lite_types.Serious as e: return_struct = module.lite_types._fbthrift_Raiser_get500_result(s=e) buf = serialize_iobuf(return_struct, protocol) exp = PythonUserException('Serious', str(e), buf) raise exp return serialize_iobuf(return_struct, protocol)
def test_primitive_types(self): s1 = PrimitiveStruct( boolField=True, byteField=127, i16Field=32767, i32Field=2147483647, i64Field=9223372036854775807, doubleField=4.56, floatField=123.0, ) serialized = serialize_iobuf(s1) s2 = deserialize(PrimitiveStruct, serialized) self.assertEqual(s1, s2)
def test_bad_enum_in_map_lookup(self) -> None: x = deserialize( ColorGroups, serialize_iobuf( OptionalColorGroups(color_map={ 1: 2, 0: 5, 6: 1, 7: 8 })), ) val = x.color_map[Color.red] self.assertBadEnum(cast(BadEnum, val), Color, 5)
def test_complex_struct(self): included = IncludedStruct(intField=456, listOfIntField=[34, 59, 28]) s1 = MyStruct(intField=456, listOfIntField=[34, 59, 28], enumField=MyEnum.ONE) s2 = AnotherStruct(structField=included, listOfStructField=[s1], listOflistOfStructField=[[s1]]) serialized = serialize_iobuf(s2) s3 = deserialize(AnotherStruct, serialized) self.assertIsNot(s3, s2) self.assertEqual(s3, s2) self.assertIsNot(s3.structField, included) self.assertEqual(s3.structField, included) self.assertEqual(s3.listOfStructField, (s1, )) self.assertEqual(s3.listOflistOfStructField, ((s1, ), ))
def test_set_type(self): s1 = MyStruct(intField=456, listOfIntField=[34, 59, 28], enumField=MyEnum.ONE) s2 = MyStruct(intField=123, listOfIntField=[12, 23], enumField=MyEnum.TWO) s3 = SetStruct( setOfI32Field={1, 2, 3, 4}, setOfStructField={s1, s2}, setOfEnumField={MyEnum.TWO, MyEnum.ONE}, setOfStringField={"hello", "world"}, ) serialized = serialize_iobuf(s3) s4 = deserialize(SetStruct, serialized) self.assertEqual(s3, s4)
def test_bad_enum_in_map_values(self) -> None: x = deserialize( ColorGroups, serialize_iobuf( OptionalColorGroups(color_map={ 1: 2, 0: 5, 6: 1, 7: 8 })), ) s = set() for k in x.color_map.values(): s.add(k) self.assertEqual(len(s), 4) s.discard(Color.green) s.discard(Color.blue) lst = sorted(s, key=lambda e: cast(BadEnum, e).value) self.assertBadEnum(cast(BadEnum, lst[0]), Color, 5) self.assertBadEnum(cast(BadEnum, lst[1]), Color, 8)
def test_bad_enum_in_map_items(self) -> None: x = deserialize( ColorGroups, serialize_iobuf( OptionalColorGroups(color_map={ 1: 2, 0: 5, 6: 1, 7: 8 })), ) for k, v in x.color_map.items(): if k == Color.blue: self.assertEqual(v, Color.green) elif k == Color.red: self.assertBadEnum(cast(BadEnum, v), Color, 5) else: ck = cast(BadEnum, k) if ck.value == 6: self.assertEqual(v, Color.blue) else: self.assertBadEnum(cast(BadEnum, v), Color, 8)
def test_union(self): type_enum_pairs = [(v.value, v.name) for v in MyUnion.Type] self.assertEqual( type_enum_pairs, [ (0, "EMPTY"), (2, "intField"), (3, "MyStructField"), (4, "AnotherStructField"), ], ) s1 = MyUnion(intField=42) self.assertIs(s1.type, MyUnion.Type.intField) self.assertEqual(s1.value, 42) s2 = StructWithAUnion(unionField=s1) serialized = serialize_iobuf(s2) s3 = deserialize(StructWithAUnion, serialized) self.assertEqual(s2, s3) self.assertTrue(s1) s4 = MyUnion() self.assertFalse(s4)
def test_deserialize_empty(self) -> None: x = deserialize(Integers, serialize_iobuf(Integers())) self.assertEqual(x.type, Integers.Type.EMPTY)
async def _fbthrift__handler_doBland(self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize(module.lite_types._fbthrift_Raiser_doBland_args, args, protocol) value = await self.doBland() return_struct = module.lite_types._fbthrift_Raiser_doBland_result() return serialize_iobuf(return_struct, protocol)
async def _fbthrift__handler_add_five(self, args: _fbthrift_iobuf.IOBuf, protocol: Protocol) -> _fbthrift_iobuf.IOBuf: args_struct = deserialize(module.lite_types._fbthrift_SimpleService_add_five_args, args, protocol) value = await self.add_five(args_struct.num,) return_struct = module.lite_types._fbthrift_SimpleService_add_five_result(success=value) return serialize_iobuf(return_struct, protocol)
def test_recursive(self): s1 = RecursiveStruct(recursiveField=RecursiveStruct(), AnotherStructField=AnotherStruct()) s2 = serialize_iobuf(s1) s3 = deserialize(RecursiveStruct, s2) self.assertEqual(s1, s3)
def test_bad_enum_in_struct(self) -> None: to_serialize = OptionalFile(name="something", type=64) serialized = serialize_iobuf(to_serialize) x = deserialize(File, serialized) self.assertBadEnum(cast(BadEnum, x.type), Kind, 64)