def test_embed_no_runtime():
"""
The function raises a ValueError if there is no runtime hex.
"""
with pytest.raises(ValueError) as ex:
uflash.embed_hex(None)
assert ex.value.args[0] == 'MicroPython runtime hex required.'
def test_embed_no_runtime():
"""
The function raises a ValueError if there is no runtime hex.
"""
with pytest.raises(ValueError) as ex:
uflash.embed_hex(None)
assert ex.value.args[0] == 'MicroPython runtime hex required.'
def test_extract():
"""
The script should be returned as a string (if there is one).
"""
python = uflash.hexlify(TEST_SCRIPT)
result = uflash.embed_hex(uflash._RUNTIME, python)
extracted = uflash.extract_script(result)
assert extracted == TEST_SCRIPT.decode('utf-8')
def test_extract():
"""
The script should be returned as a string (if there is one).
"""
python = uflash.hexlify(TEST_SCRIPT)
result = uflash.embed_hex(uflash._RUNTIME, python)
extracted = uflash.extract_script(result)
assert extracted == TEST_SCRIPT.decode('utf-8')
def test_extract_sandwiched():
"""
The script hex is packed with additional data above and bellow and should
still be returned as a the original string only.
"""
python = uflash.hexlify(TEST_SCRIPT)
python_hex_lines = python.split('\n')
python_sandwiched = [python_hex_lines[0]] + \
[':10DFE000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF41'] + \
python_hex_lines[1:] + [':10E50000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1B']
result = uflash.embed_hex(uflash._RUNTIME, '\n'.join(python_sandwiched))
extracted = uflash.extract_script(result)
assert extracted == TEST_SCRIPT.decode('utf-8')
def test_flash_with_path_to_microbit():
"""
Flash the referenced path to the micro:bit with a hex file generated from
the MicroPython firmware and the referenced Python script.
"""
with mock.patch('uflash.save_hex') as mock_save:
uflash.flash('tests/example.py', ['test_path'])
assert mock_save.call_count == 1
# Create the hex we're expecting to flash onto the device.
with open('tests/example.py', 'rb') as py_file:
python = uflash.hexlify(py_file.read())
assert python
expected_hex = uflash.embed_hex(uflash._RUNTIME, python)
assert mock_save.call_args[0][0] == expected_hex
expected_path = os.path.join('test_path', 'micropython.hex')
assert mock_save.call_args[0][1] == expected_path
def test_flash_with_path_to_microbit():
"""
Flash the referenced path to the micro:bit with a hex file generated from
the MicroPython firmware and the referenced Python script.
"""
with mock.patch('uflash.save_hex') as mock_save:
uflash.flash('tests/example.py', ['test_path'])
assert mock_save.call_count == 1
# Create the hex we're expecting to flash onto the device.
with open('tests/example.py', 'rb') as py_file:
python = uflash.hexlify(py_file.read())
assert python
expected_hex = uflash.embed_hex(uflash._RUNTIME, python)
assert mock_save.call_args[0][0] == expected_hex
expected_path = os.path.join('test_path', 'micropython.hex')
assert mock_save.call_args[0][1] == expected_path
def test_save_hex():
"""
Ensure the good case works.
"""
# Ensure we have a temporary file to write to that doesn't already exist.
path_to_hex = os.path.join(tempfile.gettempdir(), 'microbit.hex')
if os.path.exists(path_to_hex):
os.remove(path_to_hex)
assert not os.path.exists(path_to_hex)
# Create the hex file we want to "flash"
python = uflash.hexlify(TEST_SCRIPT)
hex_file = uflash.embed_hex(uflash._RUNTIME, python)
# Save the hex.
uflash.save_hex(hex_file, path_to_hex)
# Ensure the hex has been written as expected.
assert os.path.exists(path_to_hex)
with open(path_to_hex) as written_file:
assert written_file.read() == hex_file
def test_save_hex():
"""
Ensure the good case works.
"""
# Ensure we have a temporary file to write to that doesn't already exist.
path_to_hex = os.path.join(tempfile.gettempdir(), 'microbit.hex')
if os.path.exists(path_to_hex):
os.remove(path_to_hex)
assert not os.path.exists(path_to_hex)
# Create the hex file we want to "flash"
python = uflash.hexlify(TEST_SCRIPT)
hex_file = uflash.embed_hex(uflash._RUNTIME, python)
# Save the hex.
uflash.save_hex(hex_file, path_to_hex)
# Ensure the hex has been written as expected.
assert os.path.exists(path_to_hex)
with open(path_to_hex) as written_file:
assert written_file.read() == hex_file
def test_flash_has_python_no_path_to_microbit():
"""
The good case with a path to a Python file. When it's possible to find a
path to the micro:bit.
The resulting payload should be a correctly created micropython.hex file.
"""
with mock.patch('uflash.find_microbit', return_value='foo'):
with mock.patch('uflash.save_hex') as mock_save:
uflash.flash('tests/example.py')
assert mock_save.call_count == 1
# Create the hex we're expecting to flash onto the device.
with open('tests/example.py', 'rb') as py_file:
python = uflash.hexlify(py_file.read())
assert python
expected_hex = uflash.embed_hex(uflash._RUNTIME, python)
assert mock_save.call_args[0][0] == expected_hex
expected_path = os.path.join('foo', 'micropython.hex')
assert mock_save.call_args[0][1] == expected_path
def test_flash_has_python_no_path_to_microbit():
"""
The good case with a path to a Python file. When it's possible to find a
path to the micro:bit.
The resulting payload should be a correctly created micropython.hex file.
"""
with mock.patch('uflash.find_microbit', return_value='foo'):
with mock.patch('uflash.save_hex') as mock_save:
uflash.flash('tests/example.py')
assert mock_save.call_count == 1
# Create the hex we're expecting to flash onto the device.
with open('tests/example.py', 'rb') as py_file:
python = uflash.hexlify(py_file.read())
assert python
expected_hex = uflash.embed_hex(uflash._RUNTIME, python)
assert mock_save.call_args[0][0] == expected_hex
expected_path = os.path.join('foo', 'micropython.hex')
assert mock_save.call_args[0][1] == expected_path
def test_embed_hex():
"""
Ensure the good case works as expected.
"""
python = uflash.hexlify(TEST_SCRIPT)
result = uflash.embed_hex(uflash._RUNTIME, python)
# The resulting hex should be of the expected length.
assert len(result) == len(python) + len(uflash._RUNTIME) + 1 # +1 for \n
# The hex should end with a newline '\n'
assert result[-1:] == '\n'
# The Python hex should be in the correct location.
py_list = python.split()
result_list = result.split()
start_of_python_from_end = len(py_list) + 2
start_of_python = len(result_list) - start_of_python_from_end
assert result_list[start_of_python:-2] == py_list
# The firmware should enclose the Python correctly.
firmware_list = uflash._RUNTIME.split()
assert firmware_list[:-2] == result_list[:-start_of_python_from_end]
assert firmware_list[-2:] == result_list[-2:]
def test_embed_hex():
"""
Ensure the good case works as expected.
"""
python = uflash.hexlify(TEST_SCRIPT)
result = uflash.embed_hex(uflash._RUNTIME, python)
# The resulting hex should be of the expected length.
assert len(result) == len(python) + len(uflash._RUNTIME) + 1 # +1 for \n
# The hex should end with a newline '\n'
assert result[-1:] == '\n'
# The Python hex should be in the correct location.
py_list = python.split()
result_list = result.split()
start_of_python_from_end = len(py_list) + 5
start_of_python = len(result_list) - start_of_python_from_end
assert result_list[start_of_python:-5] == py_list
# The firmware should enclose the Python correctly.
firmware_list = uflash._RUNTIME.split()
assert firmware_list[:-5] == result_list[:-start_of_python_from_end]
assert firmware_list[-5:] == result_list[-5:]
def test_embed_no_python():
"""
The function returns the firmware hex value if there is no Python hex.
"""
assert uflash.embed_hex('foo') == 'foo'
def test_embed_no_python():
"""
The function returns the firmware hex value if there is no Python hex.
"""
assert uflash.embed_hex('foo') == 'foo'