class _EncodeTest(_SchemaRegistryAvroTest):
def __init__(self, arguments):
super().__init__(arguments)
self.sync_credential = DefaultAzureCredential()
self.sync_client = SchemaRegistryClient(
fully_qualified_namespace=self.fully_qualified_namespace,
credential=self.sync_credential,
)
self.sync_encoder = AvroEncoder(client=self.sync_client,
group_name=self.group_name,
auto_register_schemas=True)
self.async_credential = AsyncDefaultAzureCredential()
self.async_client = AsyncSchemaRegistryClient(
fully_qualified_namespace=self.fully_qualified_namespace,
credential=self.async_credential,
)
self.async_encoder = AsyncAvroEncoder(client=self.async_client,
group_name=self.group_name,
auto_register_schemas=True)
async def global_setup(self):
await super().global_setup()
async def close(self):
self.sync_client.close()
self.sync_credential.close()
self.sync_encoder.close()
await self.async_client.close()
await self.async_credential.close()
await self.async_encoder.close()
await super().close()
def test_basic_sr_avro_encoder_without_auto_register_schemas(self, **kwargs):
schemaregistry_fully_qualified_namespace = kwargs.pop("schemaregistry_fully_qualified_namespace")
schemaregistry_group = kwargs.pop("schemaregistry_group")
sr_client = self.create_client(fully_qualified_namespace=schemaregistry_fully_qualified_namespace)
sr_avro_encoder = AvroEncoder(client=sr_client, group_name=schemaregistry_group)
schema_str = """{"namespace":"example.avro","type":"record","name":"User","fields":[{"name":"name","type":"string"},{"name":"favorite_number","type":["int","null"]},{"name":"favorite_color","type":["string","null"]}]}"""
schema = avro.schema.parse(schema_str)
dict_content = {"name": u"Ben", "favorite_number": 7, "favorite_color": u"red"}
encoded_message_content = sr_avro_encoder.encode(dict_content, schema=schema_str)
content_type = encoded_message_content["content_type"]
encoded_content = encoded_message_content["content"]
assert content_type.split("+")[0] == 'avro/binary'
schema_id = sr_client.get_schema_properties(schemaregistry_group, schema.fullname, str(schema), "Avro").id
assert content_type.split("+")[1] == schema_id
encoded_content_dict = {"content": encoded_content, "content_type": content_type}
decoded_content = sr_avro_encoder.decode(encoded_content_dict)
assert decoded_content["name"] == u"Ben"
assert decoded_content["favorite_number"] == 7
assert decoded_content["favorite_color"] == u"red"
sr_avro_encoder.close()
)
def decode_with_content_and_content_type(encoder, event_data):
# get content as bytes
content = bytearray()
for c in event_data.body:
content += c
content_bytes = bytes(content)
message_content = MessageContent({
"content": content_bytes,
"content_type": event_data.content_type
})
decoded_content = encoder.decode(message_content)
print("Decoded content is: ", decoded_content)
return decoded_content
if __name__ == "__main__":
schema_registry = SchemaRegistryClient(
fully_qualified_namespace=SCHEMAREGISTRY_FULLY_QUALIFIED_NAMESPACE,
credential=token_credential,
)
encoder = AvroEncoder(client=schema_registry,
group_name=GROUP_NAME,
auto_register=True)
event_data = encode_message_content_dict(encoder)
decoded_content = decode_with_content_and_content_type(encoder, event_data)
encoder.close()
def test_basic_sr_avro_encoder_with_auto_register_schemas(
self, schemaregistry_fully_qualified_namespace,
schemaregistry_group, **kwargs):
sr_client = self.create_basic_client(
SchemaRegistryClient,
fully_qualified_namespace=schemaregistry_fully_qualified_namespace)
sr_avro_encoder = AvroEncoder(client=sr_client,
group_name=schemaregistry_group,
auto_register_schemas=True)
schema_str = """{"namespace":"example.avro","type":"record","name":"User","fields":[{"name":"name","type":"string"},{"name":"favorite_number","type":["int","null"]},{"name":"favorite_color","type":["string","null"]}]}"""
schema = avro.schema.parse(schema_str)
dict_data = {
"name": u"Ben",
"favorite_number": 7,
"favorite_color": u"red"
}
encoded_metadata = sr_avro_encoder.encode(dict_data, schema=schema_str)
content_type = encoded_metadata["content_type"]
encoded_data = encoded_metadata["data"]
assert content_type.split("+")[0] == 'avro/binary'
schema_id = sr_client.get_schema_properties(schemaregistry_group,
schema.fullname,
str(schema), "Avro").id
assert content_type.split("+")[1] == schema_id
encoded_data_dict = {
"data": encoded_data,
"content_type": content_type
}
decoded_data = sr_avro_encoder.decode(encoded_data_dict)
assert decoded_data["name"] == u"Ben"
assert decoded_data["favorite_number"] == 7
assert decoded_data["favorite_color"] == u"red"
# check that AvroEncoder won't work with message types that don't follow protocols
class BadExample:
def __init__(self, not_data):
self.not_data = not_data
with pytest.raises(
SchemaEncodeError) as e: # caught avro SchemaParseError
sr_avro_encoder.encode({"name": u"Ben"},
schema=schema_str,
message_type=BadExample)
assert "subtype of the MessageType" in (str(e.value))
bad_ex = BadExample('fake')
with pytest.raises(
SchemaDecodeError) as e: # caught avro SchemaParseError
sr_avro_encoder.decode(message=bad_ex)
assert "subtype of the MessageType" in (str(e.value))
# check that AvroEncoder will work with message types that follow protocols
class GoodExample:
def __init__(self, data: bytes, content_type: str, **kwargs):
self.data = data
self.content_type = content_type
self.extra = kwargs.pop('extra', None)
def __message_data__(self):
return {"data": self.data, "content_type": self.content_type}
def good_callback(data: bytes, content_type: str, **kwargs):
return GoodExample(data, content_type, **kwargs)
good_ex_obj = sr_avro_encoder.encode(dict_data,
schema=schema_str,
message_type=GoodExample,
extra='val')
good_ex_callback = sr_avro_encoder.encode(dict_data,
schema=schema_str,
message_type=good_callback,
extra='val')
decoded_data_obj = sr_avro_encoder.decode(message=good_ex_obj)
decoded_data_callback = sr_avro_encoder.decode(
message=good_ex_callback)
assert decoded_data_obj["name"] == u"Ben"
assert decoded_data_obj["favorite_number"] == 7
assert decoded_data_obj["favorite_color"] == u"red"
assert decoded_data_callback["name"] == u"Ben"
assert decoded_data_callback["favorite_number"] == 7
assert decoded_data_callback["favorite_color"] == u"red"
sr_avro_encoder.close()
def test_basic_sr_avro_encoder_with_auto_register_schemas(self, **kwargs):
schemaregistry_fully_qualified_namespace = kwargs.pop("schemaregistry_fully_qualified_namespace")
schemaregistry_group = kwargs.pop("schemaregistry_group")
sr_client = self.create_client(fully_qualified_namespace=schemaregistry_fully_qualified_namespace)
sr_avro_encoder = AvroEncoder(client=sr_client, group_name=schemaregistry_group, auto_register=True)
schema_str = """{"namespace":"example.avro","type":"record","name":"User","fields":[{"name":"name","type":"string"},{"name":"favorite_number","type":["int","null"]},{"name":"favorite_color","type":["string","null"]}]}"""
schema = avro.schema.parse(schema_str)
dict_content = {"name": u"Ben", "favorite_number": 7, "favorite_color": u"red"}
encoded_message_content = sr_avro_encoder.encode(dict_content, schema=schema_str)
content_type = encoded_message_content["content_type"]
encoded_content = encoded_message_content["content"]
# wrong data type
dict_content_bad = {"name": u"Ben", "favorite_number": 7, "favorite_color": 7}
with pytest.raises(InvalidContentError) as e:
encoded_message_content = sr_avro_encoder.encode(dict_content_bad, schema=schema_str)
assert "schema_id" in e.value.details
assert content_type.split("+")[0] == 'avro/binary'
schema_id = sr_client.get_schema_properties(schemaregistry_group, schema.fullname, str(schema), "Avro").id
assert content_type.split("+")[1] == schema_id
encoded_content_dict = {"content": encoded_content, "content_type": content_type}
decoded_content = sr_avro_encoder.decode(encoded_content_dict)
assert decoded_content["name"] == u"Ben"
assert decoded_content["favorite_number"] == 7
assert decoded_content["favorite_color"] == u"red"
# bad content type
encoded_content_dict["content_type"] = 'a+b+c'
with pytest.raises(InvalidContentError) as e:
decoded_content = sr_avro_encoder.decode(encoded_content_dict)
# check that AvroEncoder won't work with message types that don't follow protocols
class BadExample:
def __init__(self, not_content):
self.not_content = not_content
with pytest.raises(TypeError) as e:
sr_avro_encoder.encode({"name": u"Ben"}, schema=schema_str, message_type=BadExample)
assert "subtype of the MessageType" in (str(e.value))
bad_ex = BadExample('fake')
with pytest.raises(TypeError) as e: # caught TypeError
sr_avro_encoder.decode(message=bad_ex)
assert "subtype of the MessageType" in (str(e.value))
# check that AvroEncoder will work with message types that follow protocols
class GoodExample:
def __init__(self, content, **kwargs):
self.content = content
self.content_type = None
self.extra = kwargs.pop('extra', None)
@classmethod
def from_message_content(cls, content: bytes, content_type: str, **kwargs):
ge = cls(content)
ge.content_type = content_type
return ge
def __message_content__(self):
return {"content": self.content, "content_type": self.content_type}
good_ex_obj = sr_avro_encoder.encode(dict_content, schema=schema_str, message_type=GoodExample, extra='val')
decoded_content_obj = sr_avro_encoder.decode(message=good_ex_obj)
assert decoded_content_obj["name"] == u"Ben"
assert decoded_content_obj["favorite_number"] == 7
assert decoded_content_obj["favorite_color"] == u"red"
sr_avro_encoder.close()