def test_none_serialization_roundtrip(self):
# Change default from JSON to None so we test the correct serializer
serialization.registry.set_default(None)
text_data = "The Quick Brown Fox Jumps Over The Lazy Dog"
content_type, content_encoding, payload = serialization.dumps(
text_data)
self.assertIsInstance(payload, bytes)
self.assertEqual(content_type, serialization.CONTENT_TYPE_TEXT)
self.assertEqual(content_encoding, "utf-8")
recovered_data = serialization.loads(payload,
content_type=content_type,
content_encoding=content_encoding)
self.assertEqual(text_data, recovered_data)
binary_data = text_data.encode()
content_type, content_encoding, payload = serialization.dumps(
binary_data)
self.assertIsInstance(payload, bytes)
self.assertEqual(content_type, serialization.CONTENT_TYPE_DATA)
self.assertEqual(content_encoding, "binary")
recovered_data = serialization.loads(payload,
content_type=content_type,
content_encoding=content_encoding)
self.assertEqual(binary_data, recovered_data)
# check exception is raised when bytes are not passed in
with self.assertRaises(Exception) as cm:
content_type, content_encoding, payload = serialization.dumps({})
self.assertIn("Can only serialize bytes", str(cm.exception))
def on_message(self, prot, peer_id: bytes, data: bytes, **kwargs) -> None:
""" Called by a protocol when it receives a message from a peer.
:param prot: The protocol instance the received the message.
:param peer_id: The peer's unique identity which can be used to route
messages back to the originator.
:param data: The message payload.
"""
if self._on_message_handler:
type_identifier = kwargs.get("type_identifier")
data = serialization.loads(
data,
content_type=self.content_type,
content_encoding=self.content_encoding,
type_identifier=type_identifier,
)
try:
maybe_awaitable = self._on_message_handler(self,
data,
peer_id=peer_id,
**kwargs)
if inspect.isawaitable(maybe_awaitable):
self.loop.create_task(maybe_awaitable)
except Exception:
logger.exception(f"Error in on_message callback method")
return
def test_text_serialization_roundtrip(self):
text_data = "The Quick Brown Fox Jumps Over The Lazy Dog"
content_type, content_encoding, payload = serialization.dumps(
text_data, "text")
self.assertIsInstance(payload, bytes)
self.assertEqual(content_type, serialization.CONTENT_TYPE_TEXT)
self.assertEqual(content_encoding, "utf-8")
recovered_data = serialization.loads(payload,
content_type=content_type,
content_encoding=content_encoding)
self.assertEqual(text_data, recovered_data)
def test_yaml_serialization_roundtrip(self):
yaml_data = {
"string": "The quick brown fox jumps over the lazy dog",
"int": 10,
"float": 3.14159265,
"unicode": "Thé quick brown fox jumps over thé lazy dog",
"list": ["george", "jerry", "elaine", "cosmo"],
}
content_type, content_encoding, payload = serialization.dumps(
yaml_data, "yaml")
self.assertIsInstance(payload, bytes)
self.assertEqual(content_type, serialization.CONTENT_TYPE_YAML)
self.assertEqual(content_encoding, "utf-8")
recovered_data = serialization.loads(payload,
content_type=content_type,
content_encoding=content_encoding)
self.assertEqual(yaml_data, recovered_data)
def decode_payload(
data: bytes,
compression: Optional[str] = None,
content_type: Optional[str] = None,
content_encoding: Optional[str] = None,
type_identifier: Optional[int] = None,
) -> Any:
""" Decode a message payload
:param data: The message payload data to decode.
:param content_type: A string specifying the message content type. By
default the value is None.
:param compression: An optional string specifying a compression mime-type.
:param type_identifier: An integer that uniquely identifies a
registered message.
"""
if compression:
try:
_mime_type, data = decompress(data, compression)
except Exception as exc:
raise Exception(
f"Error decompressing payload using {compression}: {exc}"
) from None
try:
payload = loads(data,
content_type,
content_encoding,
type_identifier=type_identifier)
except Exception as exc:
raise Exception(
f"Error decoding payload with content-type={content_type}: {exc}"
) from None
return payload
def test_protobuf_serialization_roundtrip(self):
from position_pb2 import Position
protobuf_data = Position(latitude=130.0,
longitude=-30.0,
altitude=50.0,
status=Position.SIMULATED)
serializer = serialization.registry.get_serializer("protobuf")
type_identifier = serializer.registry.register_message(
Position, type_identifier=1)
content_type, content_encoding, payload = serialization.dumps(
protobuf_data, "protobuf", type_identifier=type_identifier)
self.assertIsInstance(payload, bytes)
self.assertEqual(content_type, serialization.CONTENT_TYPE_PROTOBUF)
self.assertEqual(content_encoding, "binary")
recovered_data = serialization.loads(
payload,
content_type=content_type,
content_encoding=content_encoding,
type_identifier=type_identifier,
)
self.assertEqual(protobuf_data, recovered_data)
def test_loads_with_invalid_name_or_type(self):
with self.assertRaises(Exception) as cm:
serialization.loads(b"a", "invalid", "unused-content-type")
self.assertIn("Invalid serializer", str(cm.exception))
def test_loads_with_no_data(self):
# No functionality is expected to be executed when no data needs
# to be deserialized.
serialization.loads(b"", "invalid", "unused-content-type")
def test_avro_serialization_roundtrip(self):
# Add schema to serializer schema registry
message_schema = {
"namespace":
"unittest.serialization",
"type":
"record",
"name":
"Test",
"fields": [
{
"name": "string",
"type": "string"
},
{
"name": "int",
"type": ["int", "null"]
},
{
"name": "float",
"type": ["float", "null"]
},
{
"name": "unicode",
"type": ["string", "null"]
},
{
"name": "list",
"type": {
"type": "array",
"items": "string"
}
},
],
}
serializer = serialization.registry.get_serializer("avro")
type_identifier = serializer.registry.register_message(
message_schema, type_identifier=1)
avro_data = {
"string": "The quick brown fox jumps over the lazy dog",
"int": 10,
"float": 3.14159265,
"unicode": "Thé quick brown fox jumps over thé lazy dog",
"list": ["george", "jerry", "elaine", "cosmo"],
}
content_type, content_encoding, payload = serialization.dumps(
avro_data, "avro", type_identifier=type_identifier)
self.assertIsInstance(payload, bytes)
self.assertEqual(content_type, serialization.CONTENT_TYPE_AVRO)
self.assertEqual(content_encoding, "binary")
recovered_data = serialization.loads(
payload,
content_type=content_type,
content_encoding=content_encoding,
type_identifier=type_identifier,
)
self.assertEqual(avro_data["string"], recovered_data["string"])
self.assertEqual(avro_data["int"], recovered_data["int"])
self.assertAlmostEqual(avro_data["float"],
recovered_data["float"],
places=6)
self.assertEqual(avro_data["unicode"], recovered_data["unicode"])
self.assertEqual(avro_data["list"], recovered_data["list"])