138 lines
5.7 KiB
Python
138 lines
5.7 KiB
Python
import unittest
|
|
|
|
from micromesh import Data, FromRadio, MeshPacket, PortNum, Position, SerialInterface, ToRadio
|
|
from micromesh.protobuf import DecodeError, decode_varint, encode_varint
|
|
from micromesh.stream import StreamParser, frame
|
|
|
|
|
|
class FakeUART:
|
|
def __init__(self, incoming=b""):
|
|
self.incoming = bytearray(incoming)
|
|
self.written = bytearray()
|
|
|
|
def any(self):
|
|
return len(self.incoming)
|
|
|
|
def read(self, count=None):
|
|
count = len(self.incoming) if count is None else count
|
|
result = bytes(self.incoming[:count])
|
|
del self.incoming[:count]
|
|
return result
|
|
|
|
def write(self, data):
|
|
self.written.extend(data)
|
|
return len(data)
|
|
|
|
|
|
class MicroMeshTests(unittest.TestCase):
|
|
def test_varint_round_trip(self):
|
|
for value in (0, 1, 127, 128, 16384, 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFF):
|
|
encoded = encode_varint(value)
|
|
self.assertEqual(decode_varint(encoded), (value, len(encoded)))
|
|
|
|
def test_known_data_wire_bytes(self):
|
|
message = Data(portnum=PortNum.TEXT_MESSAGE_APP, payload=b"hello", want_response=True)
|
|
self.assertEqual(message.SerializeToString(), b"\x08\x01\x12\x05hello\x18\x01")
|
|
self.assertEqual(Data().ParseFromString(message.SerializeToString()).to_dict(), message.to_dict())
|
|
|
|
def test_generated_style_imports(self):
|
|
from micromesh import mesh_pb2, portnums_pb2
|
|
self.assertEqual(mesh_pb2.Constants.DATA_PAYLOAD_LEN, 233)
|
|
self.assertEqual(portnums_pb2.PortNum.TEXT_MESSAGE_APP, 1)
|
|
|
|
def test_proto3_scalar_defaults_are_omitted(self):
|
|
self.assertEqual(Data(portnum=0, payload=b"", want_response=False).SerializeToString(), b"")
|
|
self.assertEqual(ToRadio(disconnect=False).SerializeToString(), b"\x20\x00")
|
|
self.assertEqual(Position(latitude_i=0).SerializeToString(), b"\x0d\x00\x00\x00\x00")
|
|
|
|
def test_mesh_packet_fixed_fields_and_nested_message(self):
|
|
packet = MeshPacket(**{"from": 0x12345678, "to": 0xFFFFFFFF, "id": 42})
|
|
packet.decoded.portnum = PortNum.TEXT_MESSAGE_APP
|
|
packet.decoded.payload = b"hi"
|
|
decoded = MeshPacket().ParseFromString(packet.SerializeToString())
|
|
self.assertEqual(decoded.from_, 0x12345678)
|
|
self.assertEqual(decoded.to, 0xFFFFFFFF)
|
|
self.assertEqual(decoded.id, 42)
|
|
self.assertEqual(decoded.decoded.payload, b"hi")
|
|
|
|
def test_signed_position(self):
|
|
original = Position(latitude_i=-1220000000, longitude_i=455000000, altitude=-12)
|
|
decoded = Position().ParseFromString(original.SerializeToString())
|
|
self.assertEqual(decoded.latitude_i, -1220000000)
|
|
self.assertEqual(decoded.altitude, -12)
|
|
|
|
def test_unknown_fields_are_preserved(self):
|
|
raw = b"\x08\x01" + encode_varint(99 << 3) + b"\x07"
|
|
parsed = Data().ParseFromString(raw)
|
|
self.assertEqual(parsed.portnum, 1)
|
|
self.assertEqual(parsed.SerializeToString(), raw)
|
|
|
|
def test_stream_parser_handles_chunks_logs_and_resync(self):
|
|
logs = []
|
|
parser = StreamParser(on_log=logs.append)
|
|
wrapped = b"debug line\n" + frame(b"one") + frame(b"two")
|
|
packets = []
|
|
for chunk in (wrapped[:3], wrapped[3:14], wrapped[14:19], wrapped[19:]):
|
|
packets.extend(parser.feed(chunk))
|
|
self.assertEqual(packets, [b"one", b"two"])
|
|
self.assertEqual(logs, ["debug line"])
|
|
|
|
def test_stream_parser_sanitizes_invalid_utf8_logs(self):
|
|
logs = []
|
|
parser = StreamParser(on_log=logs.append)
|
|
self.assertEqual(parser.feed(b"bad:\xff\xfe\n"), [])
|
|
self.assertEqual(logs, ["bad:??"])
|
|
|
|
def test_send_text_builds_to_radio_frame(self):
|
|
import micromesh.interface as interface_module
|
|
old_packet_id = interface_module._packet_id
|
|
interface_module._packet_id = lambda: 0x1234
|
|
try:
|
|
uart = FakeUART()
|
|
interface = SerialInterface(uart)
|
|
packet = interface.sendText("hello", destinationId="!aabbccdd", wantAck=True)
|
|
finally:
|
|
interface_module._packet_id = old_packet_id
|
|
sent = ToRadio().ParseFromString(StreamParser().feed(uart.written)[0])
|
|
self.assertEqual(sent.packet.to, 0xAABBCCDD)
|
|
self.assertEqual(sent.packet.id, 0x1234)
|
|
self.assertIs(sent.packet.want_ack, True)
|
|
self.assertEqual(sent.packet.decoded.portnum, PortNum.TEXT_MESSAGE_APP)
|
|
self.assertEqual(sent.packet.decoded.payload, b"hello")
|
|
self.assertEqual(packet.id, 0x1234)
|
|
|
|
def test_poll_decodes_and_tracks_state(self):
|
|
config_id = 123
|
|
uart = FakeUART(frame(FromRadio(config_complete_id=config_id).SerializeToString()))
|
|
interface = SerialInterface(uart)
|
|
interface.config_id = config_id
|
|
self.assertEqual(len(interface.poll()), 1)
|
|
self.assertIs(interface.config_complete, True)
|
|
|
|
def test_poll_can_report_and_skip_bad_frames(self):
|
|
errors = []
|
|
bad = frame(b"\x12\x05no")
|
|
good = frame(FromRadio(config_complete_id=123).SerializeToString())
|
|
interface = SerialInterface(
|
|
FakeUART(bad + good),
|
|
on_error=lambda error, payload: errors.append((error, payload)),
|
|
)
|
|
interface.config_id = 123
|
|
messages = interface.poll()
|
|
self.assertEqual(len(messages), 1)
|
|
self.assertEqual(len(errors), 1)
|
|
self.assertEqual(errors[0][1], b"\x12\x05no")
|
|
self.assertIs(interface.config_complete, True)
|
|
|
|
def test_nested_decode_errors_include_the_field_path(self):
|
|
with self.assertRaisesRegex(DecodeError, "FromRadio.packet"):
|
|
FromRadio().ParseFromString(b"\x12\x03\x22\x05x")
|
|
|
|
def test_truncated_message_raises(self):
|
|
with self.assertRaises(DecodeError):
|
|
Data().ParseFromString(b"\x12\x05no")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|