def test_parsed_start(self, model, assertion, data):
assertion(
SchemaParser.parse(SchemaParser.serialize(data, to_string=False),
model,
from_string=False),
data,
)
def to_brewtils(
obj: Union[MongoModel, List[MongoModel], QuerySet]
) -> Union[ModelItem, List[ModelItem], None]:
"""Convert an item from its Mongo model to its Brewtils one
Args:
obj: The Mongo model item or QuerySet
Returns:
The Brewtils model item
"""
if obj is None:
return obj
if isinstance(obj, (list, QuerySet)):
if len(obj) == 0:
return []
model_class = obj[0].brewtils_model
many = True
else:
model_class = obj.brewtils_model
many = False
if getattr(obj, "pre_serialize", None):
obj.pre_serialize()
serialized = MongoParser.serialize(obj, to_string=True)
parsed = SchemaParser.parse(serialized,
model_class,
from_string=True,
many=many)
return parsed
def test_many(self, model, data, assertion, expected):
parsed = SchemaParser.parse([data] * 2,
model,
from_string=False,
many=True)
for parsed_model in parsed:
assertion(parsed_model, expected)
def test_patch_model_start(self, bg_patch):
"""Patches are always parsed into a list, so they need a tweak to test"""
parsed = SchemaParser.parse(
SchemaParser.serialize(bg_patch, to_string=False),
brewtils.models.PatchOperation,
from_string=False,
)
assert len(parsed) == 1
assert_patch_equal(parsed[0], bg_patch)
def on_message(self, headers, message):
try:
parsed = SchemaParser.parse(
message,
getattr(brewtils.models, headers["model_class"]),
from_string=True,
many="True" == headers["many"],
)
print(f"Parsed message: {parsed!r}")
except AttributeError:
print("AttributeError: unable to parse message.")
def on_message(self, headers, message):
try:
parsed = SchemaParser.parse(
message,
getattr(brewtils.models, headers["model_class"]),
from_string=True,
many="True" == headers["many"],
)
print(f"Parsed message: {parsed!r}")
# Forwards an event object to a destination if payload has a metadata
try:
if "reply-to" in parsed.payload.metadata:
conn.send(
body=message,
headers=headers,
destination=parsed.payload.metadata["reply-to"],
)
except AttributeError:
pass
except AttributeError:
print("Error: unable to parse message:", message)
def test_serialized_start(self, model, data):
assert (SchemaParser.serialize(SchemaParser.parse(data,
model,
from_string=False),
to_string=False) == data)
def test_single_from_string(self):
assert_system_equal(
SchemaParser.parse("{}", brewtils.models.System, from_string=True),
System())
def test_single(self, model, data, assertion, expected):
assertion(SchemaParser.parse(data, model, from_string=False), expected)
