def test_message_inverse(x):
type_def, message = x
encoded = length_delim.encode_lendelim_message(message, type_def)
decoded, _, pos = length_delim.decode_lendelim_message(
encoded, type_def, 0)
assert isinstance(encoded, bytearray)
assert isinstance(decoded, dict)
assert pos == len(encoded)
assert message == decoded
def test_message_inverse(x):
config = Config()
typedef, message = x
encoded = length_delim.encode_lendelim_message(message, config, typedef)
decoded, typedef_out, pos = length_delim.decode_lendelim_message(
encoded, config, typedef, 0)
note(encoded)
note(typedef)
note(typedef_out)
assert isinstance(encoded, bytearray)
assert isinstance(decoded, dict)
assert pos == len(encoded)
assert message == decoded
def test_bytes_guess_inverse(x):
config = Config()
# wrap the message in a new message so that it's a guess inside
wrapper_typedef = {"1": {"type": "bytes"}}
wrapper_message = {"1": x}
encoded = length_delim.encode_lendelim_message(wrapper_message, config,
wrapper_typedef)
value, typedef, pos = length_delim.decode_lendelim_message(
encoded, config, {})
# would like to fail if it guesses wrong, but sometimes it might parse as a message
assume(typedef["1"]["type"] == "bytes")
assert isinstance(encoded, bytearray)
assert isinstance(value["1"], bytearray)
assert pos == len(encoded)
assert value["1"] == x
def test_message_guess_inverse(x):
config = Config()
type_def, message = x
# wrap the message in a new message so that it's a guess inside
wrapper_typedef = {"1": {"type": "message", "message_typedef": type_def}}
wrapper_message = {"1": message}
encoded = length_delim.encode_lendelim_message(wrapper_message, config,
wrapper_typedef)
note("Encoded length %d" % len(encoded))
value, decoded_type, pos = length_delim.decode_lendelim_message(
encoded, config, {})
note(value)
assert decoded_type["1"]["type"] == "message"
assert isinstance(encoded, bytearray)
assert isinstance(value, dict)
assert isinstance(value["1"], dict)
assert pos == len(encoded)
def test_decode_lendelim_message(buf):
try:
length_delim.decode_lendelim_message(buf)
except BlackboxProtobufException as exc:
assert not isinstance(exc, EncoderException)
pass
def check_message(orig, orig_typedef, new, new_typedef):
for field_number in set(orig.keys()) | set(new.keys()):
# verify all fields are there
assert field_number in orig
assert field_number in orig_typedef
assert field_number in new
assert field_number in new_typedef
orig_values = orig[field_number]
new_values = new[field_number]
orig_type = orig_typedef[field_number]["type"]
new_type = new_typedef[field_number]["type"]
note("Parsing field# %s" % field_number)
note("orig_values: %r" % orig_values)
note("new_values: %r" % new_values)
note("orig_type: %s" % orig_type)
note("new_type: %s" % new_type)
# Fields might be lists. Just convert everything to a list
if not isinstance(orig_values, list):
orig_values = [orig_values]
assert not isinstance(new_values, list)
new_values = [new_values]
# if the types don't match, then try to convert them
if new_type == "message" and orig_type in ["bytes", "string"]:
# if the type is a message, we want to convert the orig type to a message
# this isn't ideal, we'll be using the unintended type, but
# best way to compare. Re-encoding a message to binary might
# not keep the field order
new_field_typedef = new_typedef[field_number][
"message_typedef"]
for i, orig_value in enumerate(orig_values):
if orig_type == "bytes":
(
orig_values[i],
orig_field_typedef,
_,
) = length_delim.decode_lendelim_message(
length_delim.encode_bytes(orig_value),
config,
new_field_typedef,
)
else:
# string value
(
orig_values[i],
orig_field_typedef,
_,
) = length_delim.decode_lendelim_message(
length_delim.encode_string(orig_value),
config,
new_field_typedef,
)
orig_typedef[field_number][
"message_typedef"] = orig_field_typedef
orig_type = "message"
if new_type == "string" and orig_type == "bytes":
# our bytes were accidently valid string
new_type = "bytes"
for i, new_value in enumerate(new_values):
new_values[i], _ = length_delim.decode_bytes(
length_delim.encode_string(new_value), 0)
# sort the lists with special handling for dicts
orig_values.sort(
key=lambda x: x if not isinstance(x, dict) else x.items())
new_values.sort(
key=lambda x: x if not isinstance(x, dict) else x.items())
for orig_value, new_value in zip(orig_values, new_values):
if orig_type == "message":
check_message(
orig_value,
orig_typedef[field_number]["message_typedef"],
new_value,
new_typedef[field_number]["message_typedef"],
)
else:
assert orig_value == new_value