def test_upload_is_only_valid_if_chunk_count_matches_expected(self):
storage = LongMessageStorage(MemoryStorage(), MemoryStorage())
chunks = [b'12345', b'1234568', b'98765432']
checksum = hashlib.md5()
for chunk in chunks:
checksum.update(chunk)
expected_md5 = checksum.hexdigest()
handler = LongMessageHandler(storage)
handler.select_long_message_type(LongMessageType.FIRMWARE_DATA)
expectations = ((len(chunks), LongMessageStatus.READY),
(0, LongMessageStatus.READY),
(len(chunks) - 1, LongMessageStatus.VALIDATION_ERROR),
(len(chunks) + 1, LongMessageStatus.VALIDATION_ERROR))
for length, expected_status in expectations:
handler.init_transfer(expected_md5, length)
for chunk in chunks:
handler.upload_message(chunk)
handler.finalize_message()
status = handler.read_status()
self.assertEqual(expected_status, status.status)
def test_upload_message_with_one_byte_is_accepted(self):
persistent = MemoryStorage()
temp = MemoryStorage()
storage = LongMessageStorage(persistent, temp)
handler = LongMessageHandler(storage)
ble = LongMessageProtocol(handler)
ble.handle_write(0, [2]) # select long message 2
ble.handle_write(1, bytes([0] * 16)) # init
self.assertEqual(
LongMessageProtocol.RESULT_SUCCESS,
ble.handle_write(MessageType.UPLOAD_MESSAGE, bytes([2])))
def test_reading_unused_message_returns_zero(self):
persistent = MemoryStorage()
temp = MemoryStorage()
storage = LongMessageStorage(persistent, temp)
handler = LongMessageHandler(storage)
ble = LongMessageProtocol(handler)
ble.handle_write(0, [2]) # select long message 2
result = ble.handle_read()
# unused long message response is a 0 byte
self.assertEqual(b'\x00', result)
def test_read_returns_hash(self):
persistent = MemoryStorage()
persistent.write(2, b'abcd')
md5_hash = hashlib.md5(b'abcd').hexdigest()
temp = MemoryStorage()
storage = LongMessageStorage(persistent, temp)
handler = LongMessageHandler(storage)
ble = LongMessageProtocol(handler)
ble.handle_write(0, [2]) # select long message 2 (persistent)
result = ble.handle_read()
# reading a valid message returns its status, md5 hash and length
self.assertEqual("03" + md5_hash + "00000004", bytes2hexdigest(result))
# noinspection PyBroadException
try:
device_name = device_storage.read('device-name').decode("ascii")
if 0 == len(device_name) or len(device_name) > 15:
device_name = f'Revvy_{serial}'
except Exception:
device_name = f'Revvy_{serial}'
print(f'Device name: {device_name}')
device_name = Observable(device_name)
device_name.subscribe(
lambda v: device_storage.write('device-name', v.encode("utf-8")))
long_message_storage = LongMessageStorage(ble_storage, MemoryStorage())
extract_asset_longmessage(long_message_storage, writeable_assets_dir)
with Robot() as robot:
robot.assets.add_source(writeable_assets_dir)
long_message_handler = LongMessageHandler(long_message_storage)
robot_manager = RobotBLEController(
robot, sw_version,
RevvyBLE(device_name, serial, long_message_handler))
lmi = LongMessageImplementation(robot_manager, long_message_storage,
writeable_assets_dir, False)
long_message_handler.on_upload_started(lmi.on_upload_started)
long_message_handler.on_upload_progress(lmi.on_upload_progress)
long_message_handler.on_upload_finished(lmi.on_transmission_finished)
def test_stored_data_integrity_is_checked_on_read(self):
storage = MemoryStorage()
storage.write('foo', b'data', md5='foobar')
self.assertRaises(IntegrityError, lambda: storage.read('foo'))
def test_stored_data_can_be_read(self):
storage = MemoryStorage()
storage.write('foo', b'data')
self.assertEqual(b'data', storage.read('foo'))
def test_md5_is_calculated_if_not_provided(self):
storage = MemoryStorage()
storage.write('foo', b'data', md5='some_md5')
self.assertEqual('some_md5', storage.read_metadata('foo')['md5'])
def test_md5_is_stored_if_provided(self):
storage = MemoryStorage()
storage.write('foo', b'data')
self.assertNotEqual('', storage.read_metadata('foo')['md5'])
self.assertNotEqual(None, storage.read_metadata('foo')['md5'])
def test_reading_missing_item_raises_error(self):
storage = MemoryStorage()
self.assertRaises(StorageElementNotFoundError, lambda: storage.read_metadata('foo'))
self.assertRaises(StorageElementNotFoundError, lambda: storage.read('foo'))