def test_pickle_sequence(self) -> None:
control = I32List([1, 2, 3, 4])
self.pickle_round_robin(control)
digits = Digits(data=[Integers(tiny=1), Integers(tiny=2), Integers(large=0)])
assert digits.data
self.pickle_round_robin(digits.data)
def test_optional_struct_creation(self) -> None:
with self.assertRaises(TypeError):
easy(1, [1, 1], 'test', Integers(tiny=1)) # type: ignore
easy(val=1, an_int=Integers(small=500))
with self.assertRaises(TypeError):
easy(name=b'binary') # type: ignore
# Only Required Fields don't accept None
easy(val=5, an_int=None)
def test_optional_struct_creation(self) -> None:
with self.assertRaises(TypeError):
# pyre-fixme[19]: Expected 0 positional arguments.
easy(1, [1, 1], "test", Integers(tiny=1))
easy(val=1, an_int=Integers(small=500))
with self.assertRaises(TypeError):
# pyre-fixme[6]: Expected `Optional[str]` for 1st param but got `bytes`.
easy(name=b"binary")
# Only Required Fields don't accept None
easy(val=5, an_int=None)
def test_init_with_invalid_field(self) -> None:
with self.assertRaises(TypeError):
# pyre-ignore[28]: intentionally used a wrong field name "val_lists" for test
easy(val=1,
an_int=Integers(small=300),
name="foo",
val_lists=[1, 2, 3, 4])
def test_call_replace_required(self) -> None:
x = hard(val=5, val_list=[1, 2], name="something",
an_int=Integers(small=1), other='non default')
y = x(other=None)
self.assertEqual(y.other, "some default")
with self.assertRaises(TypeError):
x(name=None) # type: ignore
def test_required_fields_not_enforced(self) -> None:
# None is not acceptable as a string
hard( # type: ignore
val=1, val_list=[1, 2], name=None, an_int=Integers(small=1)
)
hard(val=1, val_list=[1, 2]) # type: ignore
def test_pickle_hard_struct(self) -> None:
control = hard(
val=0,
val_list=[1, 2, 3, 4],
name='foo',
an_int=Integers(tiny=1),
)
self.pickle_round_robin(control)
def test_serialize_hard_struct(self) -> None:
control = hard(
val=0,
val_list=[1, 2, 3, 4],
name='foo',
an_int=Integers(tiny=1),
)
self.thrift_serialization_round_robin(control)
def test_required_fields(self) -> None:
with self.assertRaises(TypeError):
# None is not acceptable as a string
hard(val=1, val_list=[1, 2], name=None, # type: ignore
an_int=Integers(small=1))
with self.assertRaises(TypeError):
hard(val=1, val_list=[1, 2]) # type: ignore
def test_struct(self) -> None:
x = easy(val=1, an_int=Integers(small=300), name="foo", val_list=[1, 2, 3, 4])
self.assertTrue(inspectable(x))
self.assertTrue(inspectable(easy))
r = inspect(x)
self.assertEqual(r.name, "easy")
self.assertEqual(r.kind, StructType.STRUCT)
self.assertEqual(r.annotations, {"anno1": "foo", "bar": "1"})
def test_union(self) -> None:
x = Integers(large=100)
self.assertTrue(inspectable(x))
self.assertTrue(inspectable(Integers))
r = inspect(x)
self.assertEqual(r.name, "Integers")
self.assertEqual(r.kind, StructType.UNION)
self.assertEqual(r.annotations, {})
def test_serialize_Integers_union(self) -> None:
control = Integers(medium=1337)
fixtures: Mapping[Protocol, bytes] = {
Protocol.COMPACT: b"5\xf2\x14\x00",
Protocol.BINARY: b"\x08\x00\x03\x00\x00\x059\x00",
Protocol.JSON: b'{"medium":1337}',
}
self.thrift_serialization_round_robin(control, fixtures)
def test_copy(self) -> None:
x = easy(val=1,
an_int=Integers(small=300),
name="foo",
val_list=[1, 2, 3, 4])
dif_list = copy.copy(x.val_list)
self.assertEqual(x.val_list, dif_list)
dif_int = copy.copy(x.an_int)
self.assertEqual(x.an_int, dif_int)
def test_union_usage(self) -> None:
value = hash('i64')
x = Integers(large=value)
self.assertIsInstance(x, Union)
self.assertEqual(x.type, x.get_type())
self.assertEqual(x.type, Integers.Type.large)
self.assertEqual(x.value, value)
# Hashing Works
s = set([x])
self.assertIn(x, s)
# Repr is useful
rx = repr(x)
self.assertIn(str(value), rx)
self.assertIn(x.type.name, rx)
def test_union_dir(self) -> None:
expected = [
"digits",
"large",
"medium",
"name_",
"small",
"tiny",
"type",
"unbounded",
"value",
]
self.assertEqual(expected, dir(Integers()))
self.assertEqual(expected, dir(Integers))
def test_call_replace(self) -> None:
x = easy(val=1, an_int=Integers(small=300), name="foo")
y = x(name="bar")
self.assertNotEqual(x.name, y.name)
z = y(an_int=None, val=4)
self.assertNotEqual(x.an_int, z.an_int)
self.assertNotEqual(x.val, z.val)
self.assertIsNone(z.an_int.value)
self.assertEqual(y.val, x.val)
self.assertEqual(y.an_int, x.an_int)
x = easy()
self.assertIsNotNone(x.val)
self.assertIsNotNone(x.val_list)
self.assertIsNone(x.name)
self.assertIsNotNone(x.an_int)
def test_serialize_hard_struct(self) -> None:
control = hard(
val=0, val_list=[1, 2, 3, 4], name="foo", an_int=Integers(tiny=1)
)
fixtures: Mapping[Protocol, bytes] = {
Protocol.COMPACT: b"\x15\x00\x19E\x02\x04\x06\x08\x18\x03foo\x1c\x13\x01"
b"\x00\x18\x0csome default\x00",
Protocol.BINARY: b"\x08\x00\x01\x00\x00\x00\x00\x0f\x00\x02\x08\x00\x00\x00"
b"\x04\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00"
b"\x00\x00\x04\x0b\x00\x03\x00\x00\x00\x03foo\x0c\x00\x04"
b"\x03\x00\x01\x01\x00\x0b\x00\x05\x00\x00\x00\x0csome def"
b"ault\x00",
Protocol.JSON: b'{"val":0,"val_list":[1,2,3,4],"name":"foo","an_int":{"tiny'
b'":1},"other":"some default"}',
Protocol.COMPACT_JSON: b'{"1":{"i32":0},"2":{"lst":["i32",4,1,2,3,4]},"3":'
b'{"str":"foo"},"4":{"rec":{"1":{"i8":1}}},"5":{"str":"some default"}}',
}
self.thrift_serialization_round_robin(control, fixtures)
def test_str(self) -> None:
self.assertEqual(
"easy(val=0, val_list=i[], name=None, an_int=Integers(type=EMPTY, value=None))",
str(easy()),
)
self.assertEqual(
"easy(val=0, val_list=i[], name=None, an_int=Integers(type=EMPTY, value=None))",
repr(easy()),
)
x = easy(val=1, an_int=Integers(small=300), name="foo", val_list=[1, 2, 3, 4])
self.assertEqual(
"easy(val=1, val_list=i[1, 2, 3, 4], name='foo', an_int=Integers(type=small, value=300))",
str(x),
)
self.assertEqual(
"easy(val=1, val_list=i[1, 2, 3, 4], name='foo', an_int=Integers(type=small, value=300))",
repr(x),
)
def test_wrong_type(self) -> None:
x = Integers(small=1)
with self.assertRaises(TypeError):
x.large
x.small
def test_multiple_values(self) -> None:
with self.assertRaises(TypeError):
Integers(small=1, large=2)
def test_hashability(self) -> None:
hash(Integers())
def test_isset_Union(self) -> None:
i = Integers(large=2)
with self.assertRaises(TypeError):
Struct.isset(i).large
def test_isset_Union(self) -> None:
i = Integers(large=2)
with self.assertRaises(TypeError):
# pyre-fixme[6]: Expected `HasIsSet[Variable[thrift.py3.types._T]]` for
# 1st param but got `Integers`.
Struct.isset(i).large
def test_serialize_Integers_union(self) -> None:
control = Integers(medium=1337)
self.thrift_serialization_round_robin(control)
def test_pickle_Integers_union(self) -> None:
control = Integers(large=2 ** 32)
self.pickle_round_robin(control)
