#!/usr/bin/env python # # SPDX-FileCopyrightText: 2019-2024 Espressif Systems (Shanghai) CO LTD # SPDX-License-Identifier: Apache-2.0 import json import os import shutil import subprocess import sys from typing import Any from typing import List from unittest import main from unittest import mock from unittest import TestCase import elftools.common.utils as ecu import jsonschema from elftools.elf.elffile import ELFFile try: from StringIO import StringIO except ImportError: from io import StringIO try: import idf except ImportError: sys.path.append('..') import idf current_dir = os.path.dirname(os.path.realpath(__file__)) idf_py_path = os.path.join(current_dir, '..', 'idf.py') extension_path = os.path.join(current_dir, 'test_idf_extensions', 'test_ext') py_actions_path = os.path.join(current_dir, '..', 'idf_py_actions') link_path = os.path.join(py_actions_path, 'test_ext') class TestWithoutExtensions(TestCase): @classmethod def setUpClass(cls): # Disable the component manager and extra extensions for these tests cls.env_patcher = mock.patch.dict(os.environ, { 'IDF_COMPONENT_MANAGER': '0', 'IDF_EXTRA_ACTIONS_PATH': '', }) cls.env_patcher.start() super().setUpClass() class TestExtensions(TestWithoutExtensions): def test_extension_loading(self): try: os.symlink(extension_path, link_path) os.environ['IDF_EXTRA_ACTIONS_PATH'] = os.path.join(current_dir, 'extra_path') output = subprocess.check_output([sys.executable, idf_py_path, '--help'], env=os.environ).decode('utf-8', 'ignore') self.assertIn('--test-extension-option', output) self.assertIn('test_subcommand', output) self.assertIn('--some-extension-option', output) self.assertIn('extra_subcommand', output) finally: os.remove(link_path) def test_extension_execution(self): try: os.symlink(extension_path, link_path) os.environ['IDF_EXTRA_ACTIONS_PATH'] = ';'.join([os.path.join(current_dir, 'extra_path')]) output = subprocess.check_output( [sys.executable, idf_py_path, '--some-extension-option=awesome', 'test_subcommand', 'extra_subcommand'], env=os.environ).decode('utf-8', 'ignore') self.assertIn('!!! From some global callback: awesome', output) self.assertIn('!!! From some subcommand', output) self.assertIn('!!! From test global callback: test', output) self.assertIn('!!! From some subcommand', output) finally: os.remove(link_path) def test_hidden_commands(self): try: os.symlink(extension_path, link_path) os.environ['IDF_EXTRA_ACTIONS_PATH'] = ';'.join([os.path.join(current_dir, 'extra_path')]) output = subprocess.check_output([sys.executable, idf_py_path, '--help'], env=os.environ).decode('utf-8', 'ignore') self.assertIn('test_subcommand', output) self.assertNotIn('hidden_one', output) finally: os.remove(link_path) class TestDependencyManagement(TestWithoutExtensions): def test_dependencies(self): result = idf.init_cli()( args=['--dry-run', 'flash'], standalone_mode=False, ) self.assertEqual(['flash'], list(result.keys())) def test_order_only_dependencies(self): result = idf.init_cli()( args=['--dry-run', 'build', 'fullclean', 'all'], standalone_mode=False, ) self.assertEqual(['fullclean', 'all'], list(result.keys())) def test_repeated_dependencies(self): result = idf.init_cli()( args=['--dry-run', 'fullclean', 'app', 'fullclean', 'fullclean'], standalone_mode=False, ) self.assertEqual(['fullclean', 'app'], list(result.keys())) def test_complex_case(self): result = idf.init_cli()( args=['--dry-run', 'clean', 'monitor', 'clean', 'fullclean', 'flash'], standalone_mode=False, ) self.assertEqual(['fullclean', 'clean', 'flash', 'monitor'], list(result.keys())) def test_dupplicated_commands_warning(self): capturedOutput = StringIO() sys.stderr = capturedOutput idf.init_cli()( args=['--dry-run', 'clean', 'monitor', 'build', 'clean', 'fullclean', 'all'], standalone_mode=False, ) sys.stderr = sys.__stderr__ self.assertIn( 'WARNING: Commands "all", "clean" are found in the list of commands more than once.', capturedOutput.getvalue()) sys.stderr = capturedOutput idf.init_cli()( args=['--dry-run', 'clean', 'clean'], standalone_mode=False, ) sys.stderr = sys.__stderr__ self.assertIn( 'WARNING: Command "clean" is found in the list of commands more than once.', capturedOutput.getvalue()) class TestVerboseFlag(TestWithoutExtensions): def test_verbose_messages(self): output = subprocess.check_output( [ sys.executable, idf_py_path, '-C%s' % current_dir, '-v', 'test-verbose', ], env=os.environ).decode('utf-8', 'ignore') self.assertIn('Verbose mode on', output) def test_verbose_messages_not_shown_by_default(self): output = subprocess.check_output( [ sys.executable, idf_py_path, '-C%s' % current_dir, 'test-verbose', ], env=os.environ).decode('utf-8', 'ignore') self.assertIn('Output from test-verbose', output) self.assertNotIn('Verbose mode on', output) class TestGlobalAndSubcommandParameters(TestWithoutExtensions): def test_set_twice_same_value(self): """Can set -D twice: globally and for subcommand if values are the same""" idf.init_cli()( args=['--dry-run', '-DAAA=BBB', '-DCCC=EEE', 'build', '-DAAA=BBB', '-DCCC=EEE'], standalone_mode=False, ) def test_set_twice_different_values(self): """Cannot set -D twice: for command and subcommand of idf.py (with different values)""" with self.assertRaises(idf.FatalError): idf.init_cli()( args=['--dry-run', '-DAAA=BBB', 'build', '-DAAA=EEE', '-DCCC=EEE'], standalone_mode=False, ) class TestDeprecations(TestWithoutExtensions): def test_exit_with_error_for_subcommand(self): try: subprocess.check_output( [sys.executable, idf_py_path, '-C%s' % current_dir, 'test-2'], env=os.environ, stderr=subprocess.STDOUT) except subprocess.CalledProcessError as e: self.assertIn('Error: Command "test-2" is deprecated and was removed.', e.output.decode('utf-8', 'ignore')) def test_exit_with_error_for_option(self): try: subprocess.check_output( [sys.executable, idf_py_path, '-C%s' % current_dir, '--test-5=asdf'], env=os.environ, stderr=subprocess.STDOUT) except subprocess.CalledProcessError as e: self.assertIn( 'Error: Option "test_5" is deprecated since v2.0 and was removed in v3.0.', e.output.decode('utf-8', 'ignore')) def test_deprecation_messages(self): output = subprocess.check_output( [ sys.executable, idf_py_path, '-C%s' % current_dir, '--test-0=a', '--test-1=b', '--test-2=c', '--test-3=d', 'test-0', '--test-sub-0=sa', '--test-sub-1=sb', 'ta', 'test-1', ], env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') self.assertIn('Warning: Option "test_sub_1" is deprecated and will be removed in future versions.', output) self.assertIn( 'Warning: Command "test-1" is deprecated and will be removed in future versions. ' 'Please use alternative command.', output) self.assertIn('Warning: Option "test_1" is deprecated and will be removed in future versions.', output) self.assertIn( 'Warning: Option "test_2" is deprecated and will be removed in future versions. ' 'Please update your parameters.', output) self.assertIn('Warning: Option "test_3" is deprecated and will be removed in future versions.', output) self.assertNotIn('"test-0" is deprecated', output) self.assertNotIn('"test_0" is deprecated', output) class TestHelpOutput(TestWithoutExtensions): def action_test_idf_py(self, commands: List[str], schema: Any) -> None: env = dict(**os.environ) python = shutil.which('python', path=env['PATH']) if python is None: raise ValueError('python not found') idf_path = env.get('IDF_PATH') if idf_path is None: raise ValueError('Empty IDF_PATH') idf_py_cmd = [ python, os.path.join(idf_path, 'tools', 'idf.py') ] commands = idf_py_cmd + commands output_file = 'idf_py_help_output.json' with open(output_file, 'w') as outfile: subprocess.run(commands, env=env, stdout=outfile) with open(output_file, 'r') as outfile: help_obj = json.load(outfile) self.assertIsNone(jsonschema.validate(help_obj, schema)) def test_output(self): with open(os.path.join(current_dir, 'idf_py_help_schema.json'), 'r') as schema_file: schema_json = json.load(schema_file) self.action_test_idf_py(['help', '--json'], schema_json) self.action_test_idf_py(['help', '--json', '--add-options'], schema_json) class TestROMs(TestWithoutExtensions): def get_string_from_elf_by_addr(self, filename: str, address: int) -> str: result = '' with open(filename, 'rb') as stream: elf_file = ELFFile(stream) ro = elf_file.get_section_by_name('.rodata') ro_addr_delta = ro['sh_addr'] - ro['sh_offset'] cstring = ecu.parse_cstring_from_stream(ro.stream, address - ro_addr_delta) if cstring: result = str(cstring.decode('utf-8')) return result def test_roms_validate_json(self): with open(os.path.join(py_actions_path, 'roms.json'), 'r') as f: roms_json = json.load(f) with open(os.path.join(py_actions_path, 'roms_schema.json'), 'r') as f: schema_json = json.load(f) jsonschema.validate(roms_json, schema_json) def test_roms_check_supported_chips(self): from idf_py_actions.constants import SUPPORTED_TARGETS with open(os.path.join(py_actions_path, 'roms.json'), 'r') as f: roms_json = json.load(f) for chip in SUPPORTED_TARGETS: self.assertTrue(chip in roms_json, msg=f'Have no ROM data for chip {chip}') def test_roms_validate_build_date(self): sys.path.append(py_actions_path) rom_elfs_dir = os.getenv('ESP_ROM_ELF_DIR') with open(os.path.join(py_actions_path, 'roms.json'), 'r') as f: roms_json = json.load(f) for chip in roms_json: for k in roms_json[chip]: rom_file = os.path.join(rom_elfs_dir, f'{chip}_rev{k["rev"]}_rom.elf') build_date_str = self.get_string_from_elf_by_addr(rom_file, int(k['build_date_str_addr'], base=16)) self.assertTrue(len(build_date_str) == 11) self.assertTrue(build_date_str == k['build_date_str']) class TestFileArgumentExpansion(TestCase): def test_file_expansion(self): """Test @filename expansion functionality""" try: output = subprocess.check_output( [sys.executable, idf_py_path, '--version', '@file_args_expansion_inputs/args_a'], env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') self.assertIn('Running: idf.py --version DAAA DBBB', output) except subprocess.CalledProcessError as e: self.fail(f'Process should have exited normally, but it exited with a return code of {e.returncode}') def test_multiple_file_arguments(self): """Test multiple @filename arguments""" try: output = subprocess.check_output( [sys.executable, idf_py_path, '--version', '@file_args_expansion_inputs/args_a', '@file_args_expansion_inputs/args_b'], env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') self.assertIn('Running: idf.py --version DAAA DBBB DCCC DDDD', output) except subprocess.CalledProcessError as e: self.fail(f'Process should have exited normally, but it exited with a return code of {e.returncode}') def test_recursive_expansion(self): """Test recursive expansion of @filename arguments""" try: output = subprocess.check_output( [sys.executable, idf_py_path, '--version', '@file_args_expansion_inputs/args_recursive'], env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') self.assertIn('Running: idf.py --version DAAA DBBB DEEE DFFF', output) except subprocess.CalledProcessError as e: self.fail(f'Process should have exited normally, but it exited with a return code of {e.returncode}') def test_circular_dependency(self): """Test circular dependency detection in file argument expansion""" with self.assertRaises(subprocess.CalledProcessError) as cm: subprocess.check_output( [sys.executable, idf_py_path, '--version', '@file_args_expansion_inputs/args_circular_a'], env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') self.assertIn('Circular dependency in file argument expansion', cm.exception.output.decode('utf-8', 'ignore')) def test_missing_file(self): """Test missing file detection in file argument expansion""" with self.assertRaises(subprocess.CalledProcessError) as cm: subprocess.check_output( [sys.executable, idf_py_path, '--version', '@args_non_existent'], env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') self.assertIn('(expansion of @args_non_existent) could not be opened', cm.exception.output.decode('utf-8', 'ignore')) class TestWrapperCommands(TestCase): @classmethod def setUpClass(cls): cls.sample_project_dir = os.path.join(current_dir, '..', 'test_build_system', 'build_test_app') os.chdir(cls.sample_project_dir) super().setUpClass() def call_command(self, command: List[str]) -> str: try: output = subprocess.check_output( command, env=os.environ, stderr=subprocess.STDOUT).decode('utf-8', 'ignore') return output except subprocess.CalledProcessError as e: self.fail(f'Process should have exited normally, but it exited with a return code of {e.returncode}') @classmethod def tearDownClass(cls): subprocess.run([sys.executable, idf_py_path, 'fullclean'], stdout=subprocess.DEVNULL) os.chdir(current_dir) super().tearDownClass() class TestEFuseCommands(TestWrapperCommands): """ Test if wrapper commands for espefuse.py are working as expected. The goal is NOT to test the functionality of espefuse.py, but to test if the wrapper commands are working as expected. """ def test_efuse_summary(self): summary_command = [sys.executable, idf_py_path, 'efuse-summary', '--virt'] output = self.call_command(summary_command) self.assertIn('EFUSE_NAME (Block) Description = [Meaningful Value] [Readable/Writeable] (Hex Value)', output) output = self.call_command(summary_command + ['--format','summary']) self.assertIn('00:00:00:00:00:00', output) self.assertIn('MAC address', output) output = self.call_command(summary_command + ['--format','value-only', 'WR_DIS']) self.assertIn('0', output) def test_efuse_burn(self): burn_command = [sys.executable, idf_py_path, 'efuse-burn', '--virt', '--do-not-confirm'] output = self.call_command(burn_command + ['WR_DIS', '1']) self.assertIn('\'WR_DIS\' (Efuse write disable mask) 0x0000 -> 0x0001', output) self.assertIn('Successful', output) output = self.call_command(burn_command + ['WR_DIS', '1', 'RD_DIS', '1']) self.assertIn('WR_DIS', output) self.assertIn('RD_DIS', output) self.assertIn('Successful', output) def test_efuse_burn_key(self): key_name = 'efuse_test_key.bin' subprocess.run([sys.executable, idf_py_path, 'secure-generate-flash-encryption-key', os.path.join(current_dir, key_name)], stdout=subprocess.DEVNULL) burn_key_command = [sys.executable, idf_py_path, 'efuse-burn-key', '--virt', '--do-not-confirm'] output = self.call_command(burn_key_command + ['--show-sensitive-info', 'secure_boot_v1', os.path.join(current_dir, key_name)]) self.assertIn('Burn keys to blocks:', output) self.assertIn('Successful', output) def test_efuse_dump(self): dump_command = [sys.executable, idf_py_path, 'efuse-dump', '--virt'] output = self.call_command(dump_command) self.assertIn('BLOCK0', output) self.assertIn('BLOCK1', output) self.assertIn('BLOCK2', output) self.assertIn('BLOCK3', output) def test_efuse_read_protect(self): read_protect_command = [sys.executable, idf_py_path, 'efuse-read-protect', '--virt', '--do-not-confirm'] output = self.call_command(read_protect_command + ['MAC_VERSION']) self.assertIn('MAC_VERSION', output) self.assertIn('Successful', output) def test_efuse_write_protect(self): write_protect_command = [sys.executable, idf_py_path, 'efuse-write-protect', '--virt', '--do-not-confirm'] output = self.call_command(write_protect_command + ['WR_DIS']) self.assertIn('WR_DIS', output) self.assertIn('Successful', output) class TestSecureCommands(TestWrapperCommands): """ Test if wrapper commands for espsecure.py are working as expected. The goal is NOT to test the functionality of espsecure.py, but to test if the wrapper commands are working as expected. """ @classmethod def setUpClass(cls): super().setUpClass() subprocess.run([sys.executable, idf_py_path, 'build'], stdout=subprocess.DEVNULL) cls.flash_encryption_key = 'test_key.bin' cls.signing_key = 'test_signing_key.pem' def secure_generate_flash_encryption_key(self): generate_key_command = [sys.executable, idf_py_path, 'secure-generate-flash-encryption-key', self.flash_encryption_key] output = self.call_command(generate_key_command) self.assertIn(f'Writing 256 random bits to key file {self.flash_encryption_key}', output) def secure_encrypt_flash_data(self): self.secure_generate_flash_encryption_key() encrypt_command = [sys.executable, idf_py_path, 'secure-encrypt-flash-data', '--aes-xts', '--keyfile', f'../{self.flash_encryption_key}', '--address', '0x1000', '--output', 'bootloader-enc.bin', 'bootloader/bootloader.bin'] output = self.call_command(encrypt_command) self.assertIn('Using 256-bit key', output) self.assertIn('Done', output) def test_secure_decrypt_flash_data(self): self.secure_encrypt_flash_data() decrypt_command = [sys.executable, idf_py_path, 'secure-decrypt-flash-data', '--aes-xts', '--keyfile', f'../{self.flash_encryption_key}', '--address', '0x1000', '--output', 'bootloader-dec.bin', 'bootloader-enc.bin'] output = self.call_command(decrypt_command) self.assertIn('Using 256-bit key', output) self.assertIn('Done', output) def secure_generate_signing_key(self): generate_key_command = [sys.executable, idf_py_path, 'secure-generate-signing-key', '--version', '2', '--scheme', 'rsa3072', self.signing_key] output = self.call_command(generate_key_command) self.assertIn(f'RSA 3072 private key in PEM format written to {self.signing_key}', output) self.assertIn('Done', output) def secure_sign_data(self): self.secure_generate_signing_key() sign_command = [sys.executable, idf_py_path, 'secure-sign-data', '--version', '2', '--keyfile', f'../{self.signing_key}', '--output', 'bootloader-signed.bin', 'bootloader/bootloader.bin'] output = self.call_command(sign_command) self.assertIn('Signed', output) def secure_verify_signature(self): self.secure_sign_data() sign_command = [sys.executable, idf_py_path, 'secure-verify-signature', '--version', '2', '--keyfile', f'../{self.signing_key}', 'bootloader-signed.bin'] output = self.call_command(sign_command) self.assertIn('verification successful', output) class TestMergeBinCommands(TestWrapperCommands): """ Test if merge-bin command is invoked as expected. This test is not testing the functionality of esptool.py merge_bin command, but the invocation of the command from idf.py. """ def test_merge_bin(self): merge_bin_command = [sys.executable, idf_py_path, 'merge-bin'] merged_binary_name = 'test-merge-binary.bin' output = self.call_command(merge_bin_command + ['--output', merged_binary_name]) self.assertIn(f'file {merged_binary_name}, ready to flash to offset 0x0', output) self.assertIn(f'Merged binary {merged_binary_name} will be created in the build directory...', output) if __name__ == '__main__': main()