def test_hexlify_minify():
"""
Check mangle is called as expected
"""
with mock.patch('nudatus.mangle') as mangle:
uflash.hexlify(TEST_SCRIPT, minify=True)
mangle.assert_called_once_with(TEST_SCRIPT.decode('utf-8'))
def test_hexlify_minify_without_minifier():
"""
When minification but no minifier is available a ValueError
should be raised
"""
with pytest.raises(ValueError):
with mock.patch('uflash.can_minify', False):
uflash.hexlify(TEST_SCRIPT, minify=True)
def test_unhexlify():
"""
Ensure that we can get the script back out using unhexlify and that the
result is a properly decoded string.
"""
hexlified = uflash.hexlify(TEST_SCRIPT)
unhexlified = uflash.unhexlify(hexlified)
assert unhexlified == 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():
"""
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_unhexlify():
"""
Ensure that we can get the script back out using unhexlify and that the
result is a properly decoded string.
"""
hexlified = uflash.hexlify(TEST_SCRIPT)
unhexlified = uflash.unhexlify(hexlified)
assert unhexlified == TEST_SCRIPT.decode('utf-8')
def test_hexlify():
"""
Ensure we get the expected .hex encoded result from a "good" call to the
function.
"""
result = uflash.hexlify(TEST_SCRIPT)
lines = result.split()
# The first line should be the extended linear address, ox0003
assert lines[0] == ':020000040003F7'
# There should be the expected number of lines.
assert len(lines) == 5
def test_hexlify():
"""
Ensure we get the expected .hex encoded result from a "good" call to the
function.
"""
result = uflash.hexlify(TEST_SCRIPT)
lines = result.split()
# The first line should be the extended linear address, ox0003
assert lines[0] == ':020000040003F7'
# There should be the expected number of lines.
assert len(lines) == 5
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_hexlify_empty_script():
"""
The function returns an empty string if the script is empty.
"""
assert uflash.hexlify('') == ''
def test_hexlify_empty_script():
"""
The function returns an empty string if the script is empty.
"""
assert uflash.hexlify('') == ''
def test_hexlify_validates_script_length():
input = b"A" * 8193
with pytest.raises(ValueError) as excinfo:
uflash.hexlify(input)
assert str(excinfo.value) == "Python script must be less than 8188 bytes."