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)
