Include OTAFIX bootloader variants in complete release builds

This commit is contained in:
mikecarper committed 2026-10-23 22:04:20 -07:00
1 parent bbe29fbf95
commit 0d93f73837
13 files changed
+1527 -61

No files matched your search

+183 -4
View File
@@ -8,6 +8,7 @@ import subprocess
import struct
import sys
import hashlib
from copy import deepcopy
from unittest.mock import patch
import zipfile
@@ -15,7 +16,7 @@ ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location("package_cascade_release", ROOT / "scripts/package_cascade_release.py")
package = importlib.util.module_from_spec(spec)
spec.loader.exec_module(package)
from motalib import FwIdent, Nrf52Layout, ensure_endf, ensure_nrf52_layout, target_id_for_env
from motalib import ENDF_LEN, FwIdent, Nrf52Layout, ensure_endf, ensure_nrf52_layout, target_id_for_env
class ReleaseQualificationTest(unittest.TestCase):
@@ -106,8 +107,9 @@ class ReleaseQualificationTest(unittest.TestCase):
def sensor_record(self, directory, sensor, *, target='test_repeater', target_id=None,
hw_id='TEST', app_base=0x26000, flags=0x10, fw_version=0x01110107,
version='v1.17.1.7-dev-deadbeef', storage='internal_flash_and_retained_ram',
extra_application=b''):
stem = target + '-' + sensor + '-ota-' + version
extra_application=b'', artifact_variant=''):
artifact_target = target + artifact_variant + '-' + sensor + '-ota'
stem = artifact_target + '-' + version
application, _ = ensure_endf(ensure_nrf52_layout(b'OTA: status\0invalid in-place patch geometry\0'
+ extra_application,
Nrf52Layout(app_base, 0xED000, 0xED000, flags)),
@@ -118,7 +120,7 @@ class ReleaseQualificationTest(unittest.TestCase):
archive.writestr('manifest.json', json.dumps({'manifest': {
'application': {'bin_file': 'application.bin', 'dat_file': 'application.dat'}}}))
archive.writestr('application.dat', b'fixture init')
manifest = self.manifest(target, artifact_target=target + '-' + sensor + '-ota',
manifest = self.manifest(target, artifact_target=artifact_target,
platform='NRF52_PLATFORM', build_profile='auto', capabilities=['sensor.profile.' + sensor,
'ota.update.lora'], ota_update_methods=['lora'],
verification=[dict(capability='ota.update.lora', present=True, source='linked image')],
@@ -160,6 +162,183 @@ class ReleaseQualificationTest(unittest.TestCase):
path.with_suffix('.memory.json').write_text(json.dumps(proof))
return record['manifest']
def embedded_sensor_record(self, directory, sensor, *, target='RAK_4631_repeater',
candidate=None, **options):
import nrf52_embedded_bootloader as bootloader
profile, _ = bootloader.select_profile(bootloader.load_manifest(), target)
candidate = b'\xa5' * bootloader.BOOT_SIZE if candidate is None else candidate
prefix = b'OTA: status\0invalid in-place patch geometry\0'
padding = b'\0' * (-len(prefix) % 4)
item = self.sensor_record(directory, sensor, target=target,
extra_application=padding + candidate + b'BL embedded 2.4.12\0',
artifact_variant='-with-bootloader-2.4.12', **options)
manifest = item['manifest']
manifest['capabilities'].append('bootloader.embedded')
manifest['verification'].append(dict(capability='bootloader.embedded', present=True,
source='packaged application', evidence='exact pinned candidate in packaged application'))
manifest['embedded_bootloader'] = dict(release=bootloader.VERSION, profile=profile['id'],
manifest_sha256=bootloader.MANIFEST_SHA256, asset_sha256=profile['files']['zip']['sha256'],
candidate_sha256=hashlib.sha256(candidate).hexdigest(), legacy_sha256=None,
image_bytes=bootloader.BOOT_SIZE, app_offset=len(prefix) + len(padding),
activation='ota bootloader update', automatic_delay_seconds=70)
return item
def test_ordinary_and_embedded_pairs_coexist_without_satisfying_each_other(self):
with tempfile.TemporaryDirectory() as temp:
directory = Path(temp)
ordinary = [self.sensor_record(directory, sensor, target='RAK_4631_repeater')
for sensor in ('full', 'reduced')]
embedded = [self.embedded_sensor_record(directory, sensor) for sensor in ('full', 'reduced')]
before = {p.name: p.read_bytes() for p in directory.iterdir()}
for inputs in (ordinary + embedded, list(reversed(ordinary + embedded))):
package.validate_nrf52_sensor_pairs(inputs)
self.assertEqual(package.embedded_bootloader_variant(ordinary[0]['manifest']), '')
self.assertEqual(package.embedded_bootloader_variant(embedded[0]['manifest']), '2.4.12')
self.assertIn('OTAFIX 2.4.12 bootloader', package.release_profile_label(embedded[0]['manifest']))
for wrong in (ordinary + embedded[:1], ordinary[:1] + embedded,
[ordinary[0], embedded[1]], ordinary + embedded + embedded[:1]):
with self.subTest(count=len(wrong)), self.assertRaisesRegex(ValueError, 'exactly one full'):
package.validate_nrf52_sensor_pairs(wrong)
self.assertEqual({p.name: p.read_bytes() for p in directory.iterdir()}, before)
def test_embedded_metadata_requires_exact_pinned_profile_and_packaged_proof(self):
with tempfile.TemporaryDirectory() as temp:
item = self.embedded_sensor_record(Path(temp), 'full')
package.validate_manifest(item['manifest'])
for key, value in (('release', '2.4.11'), ('profile', 'another_board'),
('manifest_sha256', 'b' * 64), ('asset_sha256', 'c' * 64),
('candidate_sha256', 'A' * 64), ('image_bytes', 40959),
('app_offset', -4), ('app_offset', 1), ('app_offset', True),
('activation', 'automatic'), ('automatic_delay_seconds', 69),
('legacy_sha256', 'd' * 64)):
manifest = deepcopy(item['manifest'])
manifest['embedded_bootloader'][key] = value
with self.subTest(key=key, value=value), self.assertRaisesRegex(ValueError, 'pinned release'):
package.validate_manifest(manifest)
for fault in ('metadata', 'capability', 'proof', 'false_proof', 'wrong_proof', 'platform'):
manifest = deepcopy(item['manifest'])
if fault == 'metadata':
manifest.pop('embedded_bootloader')
elif fault == 'capability':
manifest['capabilities'].remove('bootloader.embedded')
elif fault == 'proof':
manifest['verification'].pop()
elif fault == 'false_proof':
manifest['verification'][-1]['present'] = False
elif fault == 'wrong_proof':
manifest['verification'][-1]['source'] = 'filename'
else:
manifest['platform'] = 'ESP32_PLATFORM'
with self.subTest(fault=fault), self.assertRaises(ValueError):
package.validate_manifest(manifest)
def test_embedded_pair_checks_actual_candidate_marker_and_same_candidate_in_both_profiles(self):
with tempfile.TemporaryDirectory() as temp:
directory = Path(temp)
full = self.embedded_sensor_record(directory, 'full')
reduced = self.embedded_sensor_record(directory, 'reduced', candidate=b'\x5a' * 40960)
with self.assertRaisesRegex(ValueError, 'storage layout'):
package.validate_nrf52_sensor_pairs([full, reduced])
reduced = self.embedded_sensor_record(directory, 'reduced')
for fault in ('hash', 'offset', 'marker'):
damaged = deepcopy(full)
if fault == 'hash':
damaged['manifest']['embedded_bootloader']['candidate_sha256'] = '0' * 64
elif fault == 'offset':
damaged['manifest']['embedded_bootloader']['app_offset'] += 4
else:
path = directory / 'damaged' / damaged['files'][0].name
path.parent.mkdir(exist_ok=True)
with zipfile.ZipFile(full['files'][0]) as source, zipfile.ZipFile(path, 'w') as out:
for name in source.namelist():
data = source.read(name)
if name == 'application.bin':
identity = package.parse_endf_ident(data)
data, _ = ensure_endf(data[:-ENDF_LEN].replace(
b'BL embedded 2.4.12', b'NO embedded 2.4.12'), identity)
out.writestr(name, data)
damaged['files'] = [path]
with self.subTest(fault=fault), self.assertRaisesRegex(ValueError, 'differs from qualification'):
package.validate_nrf52_sensor_pairs([damaged, reduced])
def test_qspi_retirement_requires_matching_bootloader_variant(self):
with tempfile.TemporaryDirectory() as temp:
directory = Path(temp)
legacy_target = 'Xiao_nrf52_room_server'
primary_target = legacy_target + '_lora_ota'
legacy = [self.sensor_record(directory, sensor, target=legacy_target) for sensor in ('full', 'reduced')]
primary = [self.sensor_record(directory, sensor, target=primary_target, storage='external_qspi')
for sensor in ('full', 'reduced')]
embedded_legacy = [self.embedded_sensor_record(directory, sensor, target=legacy_target)
for sensor in ('full', 'reduced')]
embedded_primary = [self.embedded_sensor_record(directory, sensor, target=primary_target,
storage='external_qspi') for sensor in ('full', 'reduced')]
before = {p.name: p.read_bytes() for p in directory.iterdir()}
for mixed in (legacy + embedded_primary, embedded_legacy + primary):
with self.assertRaisesRegex(ValueError, 'qualified external-QSPI Full/Reduced pair'):
package.omit_retired_onboard_qspi_records(mixed)
inputs = legacy + embedded_primary + embedded_legacy + primary
self.assertCountEqual(package.omit_retired_onboard_qspi_records(inputs), primary + embedded_primary)
self.assertEqual({p.name: p.read_bytes() for p in directory.iterdir()}, before)
def test_local_release_cannot_drop_or_forge_its_bootloader_receipts(self):
from build_local_release import validate_embedded_bootloader_records
with tempfile.TemporaryDirectory() as temp:
directory = Path(temp)
folder = directory / 'firmware/lora-ota'
folder.mkdir(parents=True)
ordinary = [self.sensor_record(folder, sensor, target='RAK_4631_repeater')
for sensor in ('full', 'reduced')]
embedded = [self.embedded_sensor_record(folder, sensor) for sensor in ('full', 'reduced')]
source, version = 'deadbeef' + 'a' * 32, 'v1.17.1.7-dev'
records = ordinary + embedded
standalone = directory / 'nrf52-bootloaders'
standalone.mkdir()
(standalone / 'verified-inventory.json').write_text('{}')
receipt = validate_embedded_bootloader_records(ordinary, embedded)
catalog_receipt = {'kind': 'nrf52-standalone-bootloader-catalog', 'version': '2.4.12'}
manifest = dict(format='meshcore-local-release-v1', source_commit=source,
firmware_version=version, profile='cascade', publication='local-only',
radio=dict(frequency_mhz=910.525, bandwidth_khz=62.5, spreading_factor=7, coding_rate=5),
firmware_target_count=4, migration_board_role_count=0,
nrf52_bootloader_variants=receipt, nrf52_bootloaders=catalog_receipt,
firmware=[dict(target=item['manifest']['target'], artifact_target=item['manifest']['artifact_target'],
platform='NRF52_PLATFORM', profile='auto',
embedded_bootloader=item['manifest'].get('embedded_bootloader'),
files=[str(p.relative_to(directory)) for p in item['files']]) for item in records])
bundle = directory / ('esp32-partition-migration-' + version + '-deadbeef-release.zip')
with zipfile.ZipFile(bundle, 'w') as archive:
archive.writestr('release-manifest.json', '{}')
def write_inventory():
(directory / 'manifest.json').write_text(json.dumps(manifest))
(directory / 'SHA256SUMS.txt').write_text(''.join(
hashlib.sha256(path.read_bytes()).hexdigest() + ' ' + str(path.relative_to(directory)) + '\n'
for path in sorted(directory.rglob('*')) if path.is_file() and path.name != 'SHA256SUMS.txt'))
with patch.object(package, 'collect_artifacts', return_value=records), \
patch('package_esp32_partition_migration.BOARDS', {}), \
patch('package_nrf52_bootloaders.validate_bootloader_catalog', return_value=catalog_receipt):
write_inventory()
qualified, extras, _ = package.collect_local_release(directory, version, source)
self.assertEqual(qualified, records)
self.assertIn(standalone / 'verified-inventory.json', extras)
for fault in ('drop_variants', 'drop_catalog', 'drop_both', 'wrong_variants', 'wrong_catalog', 'entry'):
saved = deepcopy(manifest)
if fault in ('drop_variants', 'drop_both'):
manifest.pop('nrf52_bootloader_variants')
if fault in ('drop_catalog', 'drop_both'):
manifest.pop('nrf52_bootloaders')
if fault == 'wrong_variants':
manifest['nrf52_bootloader_variants']['firmware_count'] += 1
elif fault == 'wrong_catalog':
manifest['nrf52_bootloaders'] = {'version': '2.4.11'}
elif fault == 'entry':
manifest['firmware'][2]['embedded_bootloader'] = None
write_inventory()
with self.subTest(fault=fault), self.assertRaisesRegex(ValueError,
'inventor|manifest disagrees'):
package.collect_local_release(directory, version, source)
manifest = saved
def matrix_package_command(self, directory):
commit = 'deadbeef' + '0' * 32
label = 'v1.17.1.5-halo-keymind-cascade-dev'
@@ -495,7 +495,7 @@ class MigrationMetadataTest(unittest.TestCase):
archive, = (output_root / "packages").glob("*.zip")
self.fixture.check_archive(archive, "heltec-v4", expected, identity)
def test_local_release_main_passes_one_canonical_directory_to_both_later_phases(self):
def test_local_release_main_passes_one_canonical_directory_to_all_later_phases(self):
import build_local_release as recipe
environment = self.environment(MIGRATION_TEST_CONFIGURED_DIR=str(self.fixture.custom))
captured = []
@@ -505,20 +505,22 @@ class MigrationMetadataTest(unittest.TestCase):
mock.patch.dict(os.environ, environment, clear=True), \
mock.patch.object(recipe, "run_logged", side_effect=lambda command, log, env:
captured.append(("matrix", env.copy()))), \
mock.patch.object(recipe, "build_embedded_bootloader_artifacts", side_effect=lambda *args:
captured.append(("embedded", args[4].copy()))), \
mock.patch.object(recipe, "build_migration_artifacts", side_effect=lambda *args:
captured.append(("migration", args[4].copy(), args[5]))), \
mock.patch.object(recipe, "stage_release", side_effect=lambda *args:
mock.patch.object(recipe, "stage_release", side_effect=lambda *args, **kwargs:
captured.append(("package", args[5]))), \
mock.patch.object(sys, "argv", ["local-release"]), \
redirect_stdout(io.StringIO()):
recipe.main()
self.assertEqual(len(self.queries()), 1)
self.assertEqual([value[0] for value in captured], ["matrix", "migration", "package"])
for item in captured[:2]:
self.assertEqual([value[0] for value in captured], ["matrix", "embedded", "migration", "package"])
for item in captured[:3]:
self.assertEqual(item[1]["PLATFORMIO_BUILD_DIR"], str(self.fixture.custom.resolve()))
self.assertEqual(item[1]["MIGRATION_TEST_OTHER"], "preserved-option")
self.assertEqual(captured[1][2], self.fixture.custom.resolve())
self.assertEqual(captured[2][1], self.fixture.custom.resolve())
self.assertEqual(captured[2][2], self.fixture.custom.resolve())
self.assertEqual(captured[3][1], self.fixture.custom.resolve())
def test_local_utility_builder_preserves_environment_and_never_requeries_pinned_directory(self):
import build_local_release as recipe
+277
View File
@@ -2,12 +2,19 @@
"""Full selection preserves qualified transports and board capacity exceptions."""
from copy import deepcopy
from contextlib import redirect_stderr, redirect_stdout
import io
import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
from build_local_release import select_ordinary_full_records
import build_local_release as release
def record(target: str, profile: str = "full", platform: str = "ESP32_PLATFORM",
@@ -655,5 +662,275 @@ class ReleaseFullSelectionTest(unittest.TestCase):
select_ordinary_full_records([primary, legacy])
class BootloaderReleaseOrchestrationTest(unittest.TestCase):
PROFILE = {"id": "test_board", "files": {"zip": {"sha256": "a" * 64}}}
def catalog(self):
return mock.patch.multiple(release, load_bootloader_manifest=mock.Mock(return_value={}),
select_bootloader_profile=mock.Mock(return_value=(self.PROFILE, {})),
target_profiles=mock.Mock(side_effect=lambda targets: {target: {
"role": "room" if "room_" in target else "repeater",
"sourceHardware": "source_" + target, "hardware": "hardware_" + target}
for target in targets}))
def embedded(self, ordinary):
result = deepcopy(ordinary)
for item in result:
manifest = item["manifest"]
sensor = release.nrf52_sensor_profile(manifest)
manifest["artifact_target"] = (manifest["target"] + "-with-bootloader-2.4.12-"
+ sensor + "-ota")
manifest["embedded_bootloader"] = dict(release="2.4.12", profile=self.PROFILE["id"],
manifest_sha256=release.BOOTLOADER_MANIFEST_SHA256, asset_sha256="a" * 64,
legacy_sha256=None)
return result
def test_target_selection_is_exact_role_platform_sorted_and_unique(self):
eligible = sensor_pair("z_repeater") + sensor_pair("a_room_server")
excluded = [record("n_companion_radio_full", platform="NRF52_PLATFORM"),
record("n_sensor", platform="NRF52_PLATFORM"), record("esp_repeater"),
record("rp_room_server", platform="RP2040_PLATFORM")]
with self.catalog():
self.assertEqual(release.embedded_bootloader_targets(eligible + excluded),
["a_room_server", "z_repeater"])
self.assertEqual([call.args[1] for call in release.select_bootloader_profile.call_args_list],
["a_room_server", "z_repeater"])
with mock.patch.object(release, "load_bootloader_manifest") as load:
self.assertEqual(release.embedded_bootloader_targets(excluded), [])
load.assert_not_called()
def test_unsupported_requested_infrastructure_fails_instead_of_being_omitted(self):
with self.catalog(), mock.patch.object(release, "select_bootloader_profile",
side_effect=ValueError("unsupported exact board")):
with self.assertRaisesRegex(ValueError, "unsupported exact board"):
release.embedded_bootloader_targets(sensor_pair("missing_repeater"))
def test_only_unique_exact_source_hardware_catalog_exclusions_are_allowed(self):
target = "pending_repeater"
records = sensor_pair(target)
unavailable = dict(id="pending_board", meshcoreHardware=["source_" + target],
qualification={"status": "source-pending"}, reason="Exact hardware is not qualified.")
catalog = {"profiles": [], "unavailableProfiles": [unavailable]}
expected = dict(target=target, profile="pending_board", source_hardware="source_" + target,
status="source-pending", reason=unavailable["reason"])
with self.catalog(), mock.patch.object(release, "load_bootloader_manifest", return_value=catalog):
self.assertEqual(release.embedded_bootloader_selection(records), ([], [expected]))
release.select_bootloader_profile.assert_not_called()
receipt = release.validate_embedded_bootloader_records(records, [])
self.assertEqual(receipt["targets"], [])
self.assertEqual(receipt["firmware_count"], 0)
self.assertEqual(receipt["exclusions"], [expected])
for fault in ("alias_only", "duplicate", "available_conflict", "unknown_status", "empty_reason"):
invalid = deepcopy(catalog)
if fault == "alias_only":
invalid["unavailableProfiles"][0]["meshcoreHardware"] = ["hardware_" + target]
elif fault == "duplicate":
invalid["unavailableProfiles"].append(deepcopy(unavailable))
elif fault == "available_conflict":
invalid["profiles"] = [{"meshcoreHardware": ["hardware_" + target]}]
elif fault == "unknown_status":
invalid["unavailableProfiles"][0]["qualification"]["status"] = "unknown"
else:
invalid["unavailableProfiles"][0]["reason"] = " "
with self.subTest(fault=fault), self.catalog(), \
mock.patch.object(release, "load_bootloader_manifest", return_value=invalid), \
mock.patch.object(release, "select_bootloader_profile", side_effect=ValueError("unmapped")):
with self.assertRaises(ValueError):
release.embedded_bootloader_selection(records)
def test_embedded_builds_are_sequential_resumable_and_in_separate_scrubbed_output(self):
ordinary = sensor_pair("z_repeater") + sensor_pair("a_room_server")
environment = {"OUTPUT_DIR": "old", "OTHER": "keep", "PLATFORMIO_BUILD_DIR": "/pinned",
"MESHCORE_NRF52_EMBED_BOOTLOADER": "wrong",
"MESHCORE_NRF52_LEGACY_BOOTLOADER": "/unrelated"}
previous = environment.copy()
calls = []
with tempfile.TemporaryDirectory() as temp:
root = Path(temp)
def run(command, log, child):
self.assertFalse(calls and calls[-1][0] == "running")
calls.append(("running", command, log, child.copy()))
self.assertEqual(child["OUTPUT_DIR"], str(root / "embedded"))
self.assertEqual(child["PLATFORMIO_BUILD_DIR"], "/pinned")
self.assertEqual(child["OTHER"], "keep")
self.assertFalse(set(release.BOOTLOADER_ENVIRONMENT) & child.keys())
calls[-1] = ("finished", command, log, child.copy())
with self.catalog(), mock.patch.object(release, "collect_artifacts", return_value=ordinary) as collect, \
mock.patch.object(release, "run_logged", side_effect=run):
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded",
release.DEFAULT_VERSION, "deadbeef", environment)
collect.assert_called_once_with(root / "ordinary", release.DEFAULT_VERSION + "-deadbeef")
self.assertEqual([item[1][3] for item in calls], ["a_room_server", "z_repeater"])
for _, command, log, _ in calls:
self.assertEqual(command, ["bash", "build_legacy.sh", "build-firmware", command[3],
"--with-bootloader", "2.4.12", "--firmware-version", release.DEFAULT_VERSION,
"--radio-preset", "usa-cascade-fixed", "--profile", "cascade",
"--require-ota", "--resume"])
self.assertEqual(log.parent, root / "embedded/build-logs")
self.assertEqual(environment, previous)
for ordinary_dir, embedded_dir in ((root, root / "."), (root, root / "child"),
(root / "child", root)):
with mock.patch.object(release, "collect_artifacts") as collect:
with self.assertRaisesRegex(ValueError, "separate output"):
release.build_embedded_bootloader_artifacts(ordinary_dir, embedded_dir, "v", "sha", {})
collect.assert_not_called()
def test_embedded_build_failure_stops_the_next_target_and_variant_contamination_rejected(self):
ordinary = sensor_pair("a_repeater") + sensor_pair("z_repeater")
with tempfile.TemporaryDirectory() as temp:
root = Path(temp)
with self.catalog(), mock.patch.object(release, "collect_artifacts", return_value=ordinary), \
mock.patch.object(release, "run_logged", side_effect=RuntimeError("capacity rejected")) as run:
with self.assertRaisesRegex(RuntimeError, "capacity rejected"):
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded", "v", "sha", {})
self.assertEqual(run.call_count, 1)
for contaminant in self.embedded(sensor_pair("a_repeater")):
contaminant["manifest"].pop("embedded_bootloader")
with mock.patch.object(release, "collect_artifacts", return_value=[contaminant]), \
mock.patch.object(release, "run_logged") as run:
with self.assertRaisesRegex(ValueError, "ordinary firmware directory"):
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded", "v", "sha", {})
run.assert_not_called()
# A resumed stale Standard image would be discarded by ordinary
# selection. It must not hide an embedded image in the ordinary root.
filtered = record("heltec_v4_repeater", "standard")
filtered["manifest"]["artifact_target"] = "heltec_v4_repeater-with-bootloader-2.4.12"
with mock.patch.object(release, "collect_artifacts", return_value=ordinary + [filtered]), \
mock.patch.object(release, "run_logged") as run, \
mock.patch.object(release, "resolve_pio_build_dir", return_value=root / "pinned"), \
mock.patch.object(release, "git", return_value="a" * 40):
with self.assertRaisesRegex(ValueError, "ordinary firmware directory"):
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded", "v", "sha", {})
with self.assertRaisesRegex(ValueError, "ordinary firmware directory"):
release.stage_release(root / "ordinary", root / "migration", root / "release", "v", "a" * 40,
root / "pinned", embedded_work=root / "embedded")
run.assert_not_called()
def test_embedded_receipt_requires_each_ordinary_profile_exactly_once(self):
ordinary = sensor_pair("board_repeater")
embedded = self.embedded(ordinary)
before = deepcopy(ordinary + embedded)
with self.catalog():
receipt = release.validate_embedded_bootloader_records(ordinary, list(reversed(embedded)))
self.assertEqual(receipt, dict(release="2.4.12", manifest_sha256=release.BOOTLOADER_MANIFEST_SHA256,
targets=["board_repeater"], firmware_count=2, exclusions=[]))
for wrong in ([], embedded[:1], embedded + embedded[:1], self.embedded(sensor_pair("other_repeater"))):
with self.subTest(artifacts=[item["manifest"]["artifact_target"] for item in wrong]):
with self.assertRaises(ValueError):
release.validate_embedded_bootloader_records(ordinary, wrong)
for field, value in (("release", "2.4.11"), ("profile", "other"),
("manifest_sha256", "b" * 64), ("asset_sha256", "c" * 64), ("legacy_sha256", "d" * 64)):
wrong = deepcopy(embedded)
wrong[0]["manifest"]["embedded_bootloader"][field] = value
with self.subTest(field=field), self.assertRaisesRegex(ValueError, "qualification differs"):
release.validate_embedded_bootloader_records(ordinary, wrong)
for field, value in (("platform", "ESP32_PLATFORM"), ("target", "other_repeater"),
("build_profile", "standard")):
wrong = deepcopy(embedded)
wrong[0]["manifest"][field] = value
with self.subTest(field=field), self.assertRaises(ValueError):
release.validate_embedded_bootloader_records(ordinary, wrong)
self.assertEqual(ordinary + embedded, before)
def test_main_default_and_explicit_version_keep_all_four_phases_isolated(self):
for version_arg in ([], ["--firmware-version", "v1.18.0.2-halo-keymind-cascade-dev"]):
with self.subTest(argv=version_arg), tempfile.TemporaryDirectory() as temp:
root, source = Path(temp), "deadbeef" + "a" * 32
version = version_arg[-1] if version_arg else "v1.18.0.1-halo-keymind-cascade-dev"
label = version + "-deadbeef"
phases = []
environment = {"OTHER": "keep", "MESHCORE_NRF52_EMBED_BOOTLOADER": "2.4.11",
"MESHCORE_NRF52_LEGACY_BOOTLOADER": "wrong"}
def capture(name, env):
self.assertEqual(env["OTHER"], "keep")
self.assertFalse(set(release.BOOTLOADER_ENVIRONMENT) & env.keys())
self.assertEqual(env["PLATFORMIO_BUILD_DIR"], str(root / "pinned"))
phases.append(name)
with mock.patch.object(release, "ROOT", root), \
mock.patch.object(release, "git", side_effect=lambda *args: "" if args[0] == "status" else source), \
mock.patch.dict(os.environ, environment, clear=True), \
mock.patch.object(release, "resolve_pio_build_dir", return_value=root / "pinned"), \
mock.patch.object(release, "run_logged", side_effect=lambda command, log, env: capture("matrix", env)) as matrix, \
mock.patch.object(release, "build_embedded_bootloader_artifacts", side_effect=lambda *args: capture("embedded", args[4])) as embed, \
mock.patch.object(release, "build_migration_artifacts", side_effect=lambda *args: capture("migration", args[4])) as migration, \
mock.patch.object(release, "stage_release", side_effect=lambda *args, **kwargs: phases.append("stage")) as stage, \
mock.patch.object(sys, "argv", ["release"] + version_arg), redirect_stdout(io.StringIO()):
release.main()
self.assertEqual(phases, ["matrix", "embedded", "migration", "stage"])
ordinary = root / ".releases" / (".build-" + label)
embedded = root / ".releases" / (".bootloader-build-" + label)
migrated = root / ".releases" / (".migration-build-" + label)
self.assertEqual(matrix.call_args.args[2]["OUTPUT_DIR"], str(ordinary))
self.assertEqual(embed.call_args.args[:4], (ordinary, embedded, version, "deadbeef"))
self.assertEqual(migration.call_args.args[:3], (migrated, version, "deadbeef"))
self.assertEqual(stage.call_args.args[:5], (ordinary, migrated, root / ".releases" / label, version, source))
self.assertEqual(stage.call_args.kwargs, {"embedded_work": embedded})
self.assertEqual(environment["MESHCORE_NRF52_EMBED_BOOTLOADER"], "2.4.11")
def test_nonempty_embedded_resume_requires_opt_in_and_dry_run_never_builds(self):
with tempfile.TemporaryDirectory() as temp:
root, source = Path(temp), "deadbeef" + "a" * 32
work = root / ".releases" / (".bootloader-build-" + release.DEFAULT_VERSION + "-deadbeef")
work.mkdir(parents=True)
proof = work / "prior-artifact"
proof.write_bytes(b"preserve")
with mock.patch.object(release, "ROOT", root), \
mock.patch.object(release, "git", side_effect=lambda *args: "" if args[0] == "status" else source), \
mock.patch.object(release, "run_logged") as run, \
mock.patch.object(release, "resolve_pio_build_dir") as resolve, \
mock.patch.object(sys, "argv", ["release"]), redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
with self.assertRaises(SystemExit):
release.main()
run.assert_not_called()
resolve.assert_not_called()
with mock.patch.object(sys, "argv", ["release", "--dry-run"]):
release.main()
run.assert_not_called()
resolve.assert_not_called()
self.assertEqual(proof.read_bytes(), b"preserve")
def test_stage_keeps_both_variants_and_auditable_standalone_metadata(self):
ordinary = sensor_pair("board_repeater")
embedded = self.embedded(ordinary)
source = "deadbeef" + "a" * 32
with tempfile.TemporaryDirectory() as temp:
root = Path(temp)
work, embedded_work = root / "ordinary", root / "embedded"
work.mkdir(); embedded_work.mkdir()
for item in ordinary + embedded:
stem = item["manifest"]["artifact_target"]
path = (embedded_work if "embedded_bootloader" in item["manifest"] else work) / (stem + ".zip")
path.write_bytes(stem.encode("ascii"))
item["files"] = [path]
catalog = {"version": "2.4.12", "inventory_path": "inventory.json", "profile_count": 23}
def stage_catalog(destination, *, project_root):
destination.mkdir()
(destination / "inventory.json").write_text(json.dumps(catalog))
return catalog
with self.catalog(), mock.patch.object(release, "git", return_value=source), \
mock.patch.object(release, "resolve_pio_build_dir", return_value=root / "pinned"), \
mock.patch.object(release, "collect_artifacts", side_effect=[ordinary, embedded]) as collect, \
mock.patch.object(release, "BOARDS", {}), mock.patch.object(release, "bundle_release"), \
mock.patch.object(release.subprocess, "run", return_value=mock.Mock(returncode=0)), \
mock.patch("package_nrf52_bootloaders.stage_bootloader_catalog", side_effect=stage_catalog), \
redirect_stdout(io.StringIO()):
release.stage_release(work, root / "migration", root / "release", release.DEFAULT_VERSION,
source, root / "pinned", embedded_work=embedded_work)
self.assertEqual([call.args[0] for call in collect.call_args_list], [work, embedded_work])
manifest = json.loads((root / "release/manifest.json").read_text())
self.assertEqual(manifest["firmware_target_count"], 4)
self.assertEqual([item["embedded_bootloader"] is not None for item in manifest["firmware"]],
[False, False, True, True])
self.assertEqual(manifest["nrf52_bootloader_variants"]["firmware_count"], 2)
self.assertEqual(manifest["nrf52_bootloaders"], catalog)
for entry in manifest["firmware"]:
self.assertEqual(len(entry["files"]), 1)
path = root / "release" / entry["files"][0]
self.assertEqual(path.read_bytes(), entry["artifact_target"].encode("ascii"))
sums = (root / "release/SHA256SUMS.txt").read_text()
self.assertIn("nrf52-bootloaders/inventory.json", sums)
self.assertIn("70 seconds", (root / "release/README.md").read_text())
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,305 @@
#!/usr/bin/env python3
"""Standalone release assets remain exact-board, complete and independently auditable."""
from copy import deepcopy
import hashlib
import io
import json
from pathlib import Path
import struct
import sys
import tempfile
from types import SimpleNamespace
import unittest
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
from intelhex import IntelHex
import package_nrf52_bootloaders as package
def digest(data):
return hashlib.sha256(data).hexdigest()
def uf2(candidate, *, omitted=()):
"""A bootloader UF2, including independent MBR and UICR records."""
writes = [(0, b"M" * 256)]
writes += [(package.embedded.BOOT_BASE + offset, candidate[offset:offset + 256])
for offset in range(0, len(candidate), 256) if offset not in omitted]
writes += [(0x10001000, b"U" * 256)]
blocks = []
for index, (address, payload) in enumerate(writes):
blocks.append(struct.pack("<8I", 0x0A324655, 0x9E5D5157, 0x2000, address,
256, index, len(writes), package.BOOTLOADER_UF2_FAMILY)
+ payload + b"\0" * 220 + struct.pack("<I", 0x0AB16F30))
return b"".join(blocks)
class StandaloneBootloaderCatalogTest(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.root = Path(self.temporary.name)
self.project = self.root / "project"
(self.project / "docs/_data").mkdir(parents=True)
self.destination, self.cache = self.root / "stage", self.root / "cache"
self.payloads, self.candidates = {}, {}
profiles = []
for name, value, aliases in (("zeta", 0xA5, ["board_z"]),
("alpha", 0x5A, ["board_a", "board_a_qspi"])):
candidate = bytes([value]) * (package.embedded.BOOT_SIZE - 512) + b"\xff" * 512
self.candidates[name] = candidate
image = IntelHex()
image.frombytes(candidate, offset=package.embedded.BOOT_BASE)
text = io.StringIO()
image.write_hex_file(text)
contents = {"hex": text.getvalue().encode("ascii"), "uf2": uf2(candidate),
"zip": ("qualified exact-profile ZIP: " + name).encode("ascii")}
profile = dict(id=name, label=name + " exact board", storage="qspi", deviceName=name,
meshcoreHardware=aliases, files={})
for kind, payload in contents.items():
prefix = name + "_bootloader-" + package.embedded.TAG
filename = ("update-" + prefix + "_mbr.uf2" if kind == "uf2" else
prefix + "_s140_7.3.0." + kind)
url = ("https://github.com/" + package.embedded.REPOSITORY + "/releases/download/"
+ package.embedded.TAG + "/" + filename)
profile["files"][kind] = dict(name=filename, size=len(payload), sha256=digest(payload), url=url)
self.payloads[url] = payload
profiles.append(profile)
self.manifest = dict(schemaVersion=1, repository=package.embedded.REPOSITORY,
tag=package.embedded.TAG, version=package.embedded.VERSION, prerelease=False,
releaseUrl="https://github.com/" + package.embedded.REPOSITORY + "/releases/tag/" + package.embedded.TAG,
profiles=profiles, coverage=dict(releasedProfiles=2, releasedHardware=3),
unavailableProfiles=[dict(id="pending_board", reason="No normal release.")],
recoveryProfiles=[dict(id="recovery_only", files={"zip": {"url": "never-download"}})])
self.pin = mock.patch.object(package.embedded, "MANIFEST_SHA256", "")
self.pin.start()
self.addCleanup(self.pin.stop)
self.write_manifest()
self.requests = []
self.download = mock.Mock(side_effect=self.urlopen)
for module in (package, package.embedded):
patcher = mock.patch.object(module, "urlopen", self.download)
patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch.object(package.embedded, "validate_candidate_zip", side_effect=self.validate_zip)
self.validate = patcher.start()
self.addCleanup(patcher.stop)
def write_manifest(self):
raw = (json.dumps(self.manifest, sort_keys=True) + "\n").encode("ascii")
(self.project / "docs/_data/bootloader_manifest.json").write_bytes(raw)
package.embedded.MANIFEST_SHA256 = digest(raw)
def urlopen(self, url, *, timeout):
self.assertEqual(timeout, 60)
self.requests.append(url)
return io.BytesIO(self.payloads[url])
def validate_zip(self, data, profile, project_root):
# The production ZIP identity/layout parser has its own real-format suite.
# Stub only that boundary while running the real download and HEX/UF2 checks.
self.assertEqual(project_root, self.project)
self.assertEqual(data, self.payloads[profile["files"]["zip"]["url"]])
return self.candidates[profile["id"]], SimpleNamespace(device_name=profile["deviceName"],
board_id=123, app_base=0x27000, softdevice_fwid=0x100)
def stage(self, destination=None):
return package.stage_bootloader_catalog(destination or self.destination,
project_root=self.project, cache_dir=self.cache)
def files(self, directory):
return {path.name: path.read_bytes() for path in directory.iterdir()}
def replace_payload(self, profile, kind, payload):
asset = profile["files"][kind]
self.payloads[asset["url"]] = payload
asset.update(size=len(payload), sha256=digest(payload))
self.write_manifest()
def test_complete_catalog_is_deterministic_cached_and_offline_verifiable(self):
receipt = self.stage()
self.assertEqual(receipt["profile_count"], 2)
self.assertEqual(receipt["hardware_count"], 3)
self.assertEqual([p["id"] for p in receipt["profiles"]], ["alpha", "zeta"])
self.assertEqual(receipt["excluded_profiles"], ["pending_board"])
self.assertEqual(len(receipt["assets"]), 6)
self.assertEqual(set(self.requests), set(self.payloads))
self.assertEqual(len(self.requests), 6)
for asset in receipt["assets"]:
data = (self.destination / asset["path"]).read_bytes()
self.assertEqual(len(data), asset["size"])
self.assertEqual(digest(data), asset["sha256"])
self.assertEqual(asset["name"], asset["path"])
before = self.files(self.destination)
self.assertNotIn("recovery_only", " ".join(before))
with mock.patch.object(package, "urlopen", side_effect=AssertionError("network forbidden")), \
mock.patch.object(package.embedded, "urlopen", side_effect=AssertionError("network forbidden")), \
mock.patch.object(package.embedded, "download_zip", side_effect=AssertionError("download forbidden")):
self.assertEqual(package.validate_bootloader_catalog(self.destination, project_root=self.project), receipt)
second = self.root / "second"
self.assertEqual(self.stage(second), receipt)
self.assertEqual(self.files(second), before)
self.assertEqual(len(self.requests), 6) # Every second download came from verified cache.
self.assertNotIn(str(self.root), json.dumps(receipt))
self.assertEqual(sorted(self.cache.iterdir()), sorted(path for path in self.cache.iterdir()
if any(path.name == asset["sha256"] + "-" + asset["name"] for asset in receipt["assets"])))
def test_corrupt_cache_is_refetched_and_only_verified_bytes_are_published(self):
self.stage()
profile = self.manifest["profiles"][0]
asset = profile["files"]["hex"]
cache = self.cache / (asset["sha256"] + "-" + asset["name"])
cache.write_bytes(b"x" * asset["size"])
self.stage(self.root / "second")
self.assertEqual(self.requests.count(asset["url"]), 2)
self.assertEqual(cache.read_bytes(), self.payloads[asset["url"]])
def test_invalid_catalog_metadata_fails_before_any_asset_download(self):
original = deepcopy(self.manifest)
for fault in ("traversal", "wrong_url", "zero_size", "bool_size", "bad_hash", "missing_format",
"duplicate_profile", "duplicate_hardware", "coverage", "unavailable_overlap"):
self.manifest = deepcopy(original)
profile = self.manifest["profiles"][0]
asset = profile["files"]["hex"]
if fault == "traversal":
asset["name"] = "../boot.hex"
elif fault == "wrong_url":
asset["url"] = "https://example.invalid/" + asset["name"]
elif fault == "zero_size":
asset["size"] = 0
elif fault == "bool_size":
asset["size"] = True
elif fault == "bad_hash":
asset["sha256"] = "A" * 64
elif fault == "missing_format":
profile["files"].pop("uf2")
elif fault == "duplicate_profile":
self.manifest["profiles"].append(deepcopy(profile))
elif fault == "duplicate_hardware":
self.manifest["profiles"][1]["meshcoreHardware"].append("board_z")
elif fault == "coverage":
self.manifest["coverage"]["releasedHardware"] = 4
else:
self.manifest["unavailableProfiles"][0]["id"] = profile["id"]
self.write_manifest()
with self.subTest(fault=fault), self.assertRaises(ValueError):
self.stage()
self.assertEqual(self.requests, [])
self.assertFalse(self.destination.exists())
def test_changed_source_manifest_pin_fails_before_asset_download(self):
path = self.project / "docs/_data/bootloader_manifest.json"
path.write_bytes(path.read_bytes() + b" ")
with self.assertRaisesRegex(ValueError, "pinned OTAFIX"):
self.stage()
self.assertEqual(self.requests, [])
self.assertFalse(self.destination.exists())
def test_late_bad_download_keeps_output_absent_and_cache_free_of_partial_files(self):
profile = self.manifest["profiles"][0] # zeta sorts last, after a complete first profile.
asset = profile["files"]["uf2"]
self.payloads[asset["url"]] += b"unexpected trailing byte"
with self.assertRaisesRegex(ValueError, "size/SHA-256 mismatch"):
self.stage()
self.assertGreater(len(self.requests), 3)
self.assertFalse(self.destination.exists())
self.assertFalse((self.cache / (asset["sha256"] + "-" + asset["name"])).exists())
self.assertFalse(list(self.cache.glob("otafix-*")))
self.assertFalse(list(self.root.glob(".stage-*")))
def test_paired_formats_must_reproduce_the_zip_candidate_even_when_asset_hashes_match(self):
original = deepcopy(self.manifest)
original_payloads = self.payloads.copy()
for kind in ("hex", "uf2"):
self.manifest = deepcopy(original)
self.payloads = original_payloads.copy()
profile = self.manifest["profiles"][0]
other_profile = self.manifest["profiles"][1]
other = self.payloads[other_profile["files"][kind]["url"]]
self.replace_payload(profile, kind, other)
with self.subTest(kind=kind), self.assertRaisesRegex(ValueError, "exact.*profile bootloader"):
self.stage()
self.assertFalse(self.destination.exists())
def test_sparse_uf2_erased_tail_is_allowed_but_missing_live_bytes_are_rejected(self):
profile = self.manifest["profiles"][0]
candidate = self.candidates[profile["id"]]
erased = (len(candidate) - 512, len(candidate) - 256)
self.replace_payload(profile, "uf2", uf2(candidate, omitted=erased))
self.stage()
self.replace_payload(profile, "uf2", uf2(candidate, omitted=(0,)))
with self.assertRaisesRegex(ValueError, "exact.*profile bootloader"):
self.stage(self.root / "bad")
self.assertFalse((self.root / "bad").exists())
def test_uf2_rejects_application_family_unsafe_writes_overlap_and_bad_block_metadata(self):
original = deepcopy(self.manifest)
profile = original["profiles"][0]
data = self.payloads[profile["files"]["uf2"]["url"]]
for fault in ("application_family", "unsafe_address", "overlap", "block_index", "block_count", "magic"):
self.manifest = deepcopy(original)
damaged = bytearray(data)
if fault == "application_family":
struct.pack_into("<I", damaged, 28, 0xADA52840)
elif fault == "unsafe_address":
struct.pack_into("<I", damaged, 12, 0x27000)
elif fault == "overlap":
struct.pack_into("<I", damaged, 512 + 12, 0)
elif fault == "block_index":
struct.pack_into("<I", damaged, 20, 1)
elif fault == "block_count":
struct.pack_into("<I", damaged, 24, 1)
else:
struct.pack_into("<I", damaged, 508, 0)
self.replace_payload(self.manifest["profiles"][0], "uf2", bytes(damaged))
with self.subTest(fault=fault), self.assertRaisesRegex(ValueError, "UF2 geometry"):
self.stage()
self.assertFalse(self.destination.exists())
def test_offline_validator_rejects_missing_extra_mutated_and_symlinked_contents(self):
self.stage()
original = self.files(self.destination)
asset_name = self.manifest["profiles"][0]["files"]["hex"]["name"]
for fault in ("missing", "extra", "hash", "inventory", "checksums", "readme", "manifest", "symlink"):
directory = self.root / ("tampered-" + fault)
directory.mkdir()
for name, data in original.items():
(directory / name).write_bytes(data)
if fault == "missing":
(directory / asset_name).unlink()
elif fault == "extra":
(directory / "unqualified.hex").write_bytes(b"extra")
elif fault == "symlink":
(directory / asset_name).unlink()
(directory / asset_name).symlink_to(self.destination / asset_name)
else:
path = directory / {"hash": asset_name, "inventory": package.INVENTORY_NAME,
"checksums": package.CHECKSUMS_NAME, "readme": package.README_NAME,
"manifest": package.MANIFEST_NAME}[fault]
data = path.read_bytes()
path.write_bytes(bytes([data[0] ^ 1]) + data[1:])
with self.subTest(fault=fault), self.assertRaises(ValueError):
package.validate_bootloader_catalog(directory, project_root=self.project)
self.assertEqual(len(self.requests), 6)
def test_nonempty_destination_and_symlink_cache_are_refused_without_mutation(self):
self.destination.mkdir()
marker = self.destination / "keep"
marker.write_bytes(b"original")
with self.assertRaisesRegex(ValueError, "empty directory"):
self.stage()
self.assertEqual(marker.read_bytes(), b"original")
marker.unlink()
target = self.root / "cache-target"
target.mkdir()
self.cache.symlink_to(target, target_is_directory=True)
with self.assertRaisesRegex(ValueError, "cache must not be a symlink"):
self.stage()
self.assertEqual(list(self.destination.iterdir()), [])
self.assertEqual(self.requests, [])
if __name__ == "__main__":
unittest.main()
+49
View File
@@ -104,6 +104,55 @@ class ReleasePublicationTest(unittest.TestCase):
with self.assertRaisesRegex(ValueError, "different family"):
catalogs.read_stage(directory)
def test_catalog_distinguishes_qualified_bootloader_firmware_from_ordinary_images(self):
from nrf52_embedded_bootloader import (BOOT_SIZE, MANIFEST_SHA256, VERSION as BL_VERSION,
load_manifest, select_profile)
with tempfile.TemporaryDirectory() as temp:
directory = Path(temp)
plan = self.stage(directory)
target = "RAK_4631_repeater"
artifact = target + "-with-bootloader-" + BL_VERSION + "-full-ota"
row, _ = self.record(directory / "lora-ota", artifact, "NRF52_PLATFORM", "full")
row["target"] = target
profile, _ = select_profile(load_manifest(), target)
row["capabilities"] = ["bootloader.embedded"]
row["verification"] = [{"capability": "bootloader.embedded", "present": True,
"source": "packaged application"}]
row["embedded_bootloader"] = {
"release": BL_VERSION, "profile": profile["id"],
"candidate_sha256": "a" * 64,
"asset_sha256": profile["files"]["zip"]["sha256"],
"manifest_sha256": MANIFEST_SHA256, "legacy_sha256": None,
"app_offset": 4, "image_bytes": BOOT_SIZE,
"activation": "ota bootloader update", "automatic_delay_seconds": 70}
folder = directory / "lora-ota"
rows = json.loads((folder / "TARGET-MANIFEST.json").read_text()) + [row]
def inventory():
(folder / "TARGET-MANIFEST.json").write_text(json.dumps(rows))
(folder / "SHA256SUMS.txt").write_text("".join(
hashlib.sha256(p.read_bytes()).hexdigest() + " " + p.name + "\n"
for p in sorted(folder.iterdir()) if p.name != "SHA256SUMS.txt"))
inventory()
next(group for group in plan["groups"] if group["key"] == "lora-ota")["target_count"] = 3
(directory / "release-plan.json").write_text(json.dumps(plan))
plan, family, records = catalogs.read_stage(directory)
targets = {r["publication_target"] for r, _, _ in records} | {
"Station_G2_companion_radio_full", "Station_G2_repeater", target}
result = catalogs.generate(self.template(), plan, family, records,
catalogs.target_profiles(targets), "mikecarper/MeshCore")
entries = result["device"][1]["firmware"]
self.assertEqual(len(entries), 3)
embedded = next(item for item in entries if artifact in item["subTitle"])
self.assertIn("OTAFIX " + BL_VERSION + " bootloader", embedded["subTitle"])
self.assertIn("70 seconds", embedded["version"][FAMILY]["notes"])
for ordinary in (item for item in entries if item is not embedded):
self.assertIn("preserve the installed bootloader", ordinary["version"][FAMILY]["notes"])
# A publication name cannot opt into automatic bootloader changes.
row.pop("embedded_bootloader")
inventory()
with self.assertRaisesRegex(ValueError, "embedded bootloader lacks qualified metadata"):
catalogs.read_stage(directory)
def test_catalog_does_not_guess_an_unknown_hardware_card(self):
with tempfile.TemporaryDirectory() as temp:
directory = Path(temp)