def test_init_with_invalid_field(self) -> None:
with self.assertRaises(TypeError):
# pyre-ignore[28]: for test
easy(val=1,
an_int=Integers(small=300),
name="foo",
val_lists=[1, 2, 3, 4])
def test_struct_in_map(self) -> None:
a = StrEasyMap({"a": easy()})
b = StrEasyMap({"a": easy(val=0)})
c = StrEasyMap({"a": easy(val=1)})
d = StrEasyMap({"a": easy(val_list=[])})
self.assertEqual(a, b)
self.assertEqual(a, d)
self.assertNotEqual(a, c)
def test_update_conflicting_nested_fields(self) -> None:
n = Nested1(a=Nested2(b=Nested3(c=easy(val=42, name="foo"))))
with self.assertRaises(ValueError):
n = update_nested_field(
n,
{
"a.b.c": easy(val=128),
"a.b.c.val": 256,
},
)
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_struct_list(self) -> None:
a = EasyList([easy()])
b = EasyList([easy(val=0)])
c = EasyList([easy(val=1)])
d = EasyList([easy(val_list=[])])
e = EasyList([easy(val_list=[1])])
self.assertEqual(a, b)
self.assertEqual(a, d)
self.assertNotEqual(a, c)
self.assertLess(a, c)
self.assertGreater(c, e)
self.assertLess(d, e)
self.assertGreater(e, d)
self.assertLessEqual(a, b)
self.assertGreaterEqual(a, d)
self.assertLessEqual(a, c)
self.assertGreaterEqual(c, e)
def test_from_thread_pool(self) -> None:
control = easy(val=5, val_list=[1, 2, 3, 4])
loop = asyncio.get_event_loop()
coro = loop.run_in_executor(None, serialize, control)
encoded = loop.run_until_complete(coro)
coro = loop.run_in_executor(None, deserialize, type(control), encoded)
decoded = loop.run_until_complete(coro)
self.assertEqual(control, decoded)
def test_optional_struct_creation(self) -> None:
with self.assertRaises(TypeError):
# pyre-ignore[19]: for test
easy(1, [1, 1], "test", Integers(tiny=1))
easy(val=1, an_int=Integers(small=500))
with self.assertRaises(TypeError):
# pyre-ignore[6]: for test
easy(name=b"binary")
# Only Required Fields don't accept None
easy(val=5, an_int=None)
def test_deepcopy(self) -> None:
x = easy(val=1,
an_int=Integers(small=300),
name="bar",
val_list=[1, 2, 3, 4])
dif = copy.deepcopy(x)
self.assertEqual(x.val, dif.val)
self.assertEqual(x.val_list, dif.val_list)
self.assertEqual(x.name, dif.name)
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_deserialize_with_length(self) -> None:
control = easy(val=5, val_list=[1, 2, 3, 4, 5])
for proto in Protocol:
encoded = serialize(control, protocol=proto)
decoded, length = deserialize_with_length(
type(control), encoded, protocol=proto
)
self.assertIsInstance(decoded, type(control))
self.assertEqual(decoded, control)
self.assertEqual(length, len(encoded))
def test_update_invalid_nested_fields(self) -> None:
n = Nested1(a=Nested2(b=Nested3(c=easy(val=42, name="foo"))))
with self.assertRaises(ValueError):
update_nested_field(n, {"": 0})
with self.assertRaises(ValueError):
update_nested_field(n, {"e": 0})
with self.assertRaises(ValueError):
update_nested_field(n, {"a.b.e": 0})
with self.assertRaises(ValueError):
update_nested_field(n, {"a.e.f": 0})
def test_serialize_Complex(self) -> None:
control = Complex(
val_bool=True,
val_i32=42,
val_i64=1 << 33,
val_string="hello\u4e16\u754c",
val_binary=b"\xe5\x92\x8c\xe5\b9\xb3",
val_iobuf=IOBuf(b"\xe5\x9b\x9b\xe5\x8d\x81\xe4\xba\x8c"),
val_enum=Color.green,
val_union=ComplexUnion(double_val=1.234),
val_set={easy(val=42)},
val_map={"foo": b"foovalue"},
val_complex_map={"bar": [{easy(val=42), easy(val_list=[1, 2, 3])}]},
val_struct_with_containers=ColorGroups(
color_list=[Color.blue, Color.green],
color_set={Color.blue, Color.red},
color_map={Color.blue: Color.green},
),
)
self.thrift_serialization_round_trip(control)
def test_update_multiple_nested_fields(self) -> None:
n = Nested1(a=Nested2(b=Nested3(c=easy(val=42, name="foo"))))
n = update_nested_field(
n,
{
"a.b.c.name": "bar",
"a.b.c.val": 256,
},
)
self.assertEqual(n.a.b.c.name, "bar")
self.assertEqual(n.a.b.c.val, 256)
def test_sanity(self) -> None:
with self.assertRaises(TypeError):
# pyre-ignore[6]: intentionally introduced for testing
serialize(1, Protocol.COMPACT)
with self.assertRaises(TypeError):
# pyre-ignore[6]: intentionally introduced for testing
serialize(easy(), None)
with self.assertRaises(TypeError):
# pyre-ignore[6]: intentionally introduced for testing
deserialize(Protocol, b"")
def test_struct_set(self) -> None:
a = EasySet({easy()})
b = EasySet({easy(val=0)})
c = EasySet({easy(val=1)})
d = EasySet({easy(val_list=[])})
f = EasySet({easy(), easy(val_list=[1])})
self.assertEqual(a, b)
self.assertEqual(a, d)
self.assertNotEqual(a, c)
self.assertEqual(a & b, {easy()})
self.assertEqual(a | b, {easy()})
self.assertEqual(a - b, set())
self.assertEqual(a ^ b, set())
self.assertLess(a, f)
self.assertGreater(f, a)
self.assertLessEqual(a, b)
self.assertLessEqual(a, f)
self.assertGreaterEqual(a, d)
self.assertGreaterEqual(f, a)
def test_hashability(self) -> None:
hash(easy().val_list)
hash(I32List(range(10)))
def test_serialize_easy_struct(self) -> None:
control = easy(val=5, val_list=[1, 2, 3, 4])
self.thrift_serialization_round_trip(control)
def test_dir(self) -> None:
expected = ["__iter__", "an_int", "name", "val", "val_list"]
self.assertEqual(expected, dir(easy()))
self.assertEqual(expected, dir(easy))
def test_serialize_iobuf(self) -> None:
control = easy(val=5, val_list=[1, 2, 3, 4, 5])
iobuf = serialize_iobuf(control)
decoded = deserialize(type(control), iobuf)
self.assertEqual(control, decoded)
def test_autospec_iterable(self) -> None:
for _ in mock.create_autospec(easy):
pass
for _ in mock.create_autospec(easy()):
pass
def test_repr(self) -> None:
self.assertEqual(
"easy(val=42, val_list=i[], name=None, an_int=Integers(type=EMPTY, value=None))",
repr(easy(val=42)),
)
def test_hashability(self) -> None:
hash(easy())
def test_update_nested_fields(self) -> None:
n = Nested1(a=Nested2(b=Nested3(c=easy(val=42, name="foo"))))
n = update_nested_field(n, {"a.b.c": easy(val=128)})
self.assertEqual(n.a.b.c.val, 128)
def test_to_python(self) -> None:
e = easy()
self.assertEqual(e, e._to_python())
