|
6 | 6 | No USB, serial, BLE, flash programming, or physical qualification occurs here. |
7 | 7 | """ |
8 | 8 | import importlib.util |
| 9 | +import hashlib |
| 10 | +import asyncio |
9 | 11 | from pathlib import Path |
10 | 12 | import struct |
11 | 13 | import sys |
@@ -193,7 +195,9 @@ def test_duplicate_serial_alias_must_be_idle_before_open(self): |
193 | 195 | mock.patch.object(HARDWARE.subprocess, "run", return_value=SimpleNamespace(returncode=0, stdout=b"occupied")) as run: |
194 | 196 | with self.assertRaises(ValueError): |
195 | 197 | HARDWARE._usb_exact(selected, idle=True) |
196 | | - self.assertEqual(run.call_args.args[0], ["/usr/sbin/lsof", selected["port"], alias["port"]]) |
| 198 | + self.assertEqual(run.call_args.args[0], ["/usr/sbin/lsof", selected["port"], |
| 199 | + selected["port"].replace("/dev/cu.", "/dev/tty."), alias["port"], |
| 200 | + alias["port"].replace("/dev/cu.", "/dev/tty.")]) |
197 | 201 |
|
198 | 202 |
|
199 | 203 | class WorkspaceHardwareLifecycleTests(unittest.IsolatedAsyncioTestCase): |
@@ -281,6 +285,94 @@ def write(self, raw): |
281 | 285 | self.backend._usb_command_sync("pass", False) |
282 | 286 | self.assertEqual(writes, [b"\x03\x03\x02\x01"]) |
283 | 287 |
|
| 288 | + async def test_esp_erase_needs_unchanged_candidate_and_verified_full_chip_digest(self): |
| 289 | + validate = mock.Mock(side_effect=ValueError("candidate changed")) |
| 290 | + adapter = HARDWARE._EspAdapter(binding(), self.root, validate) |
| 291 | + adapter._check = mock.Mock() |
| 292 | + adapter.esp = SimpleNamespace(erase_flash=mock.Mock(), flash_md5sum=mock.Mock(return_value="bad")) |
| 293 | + with self.assertRaisesRegex(ValueError, "candidate changed"): |
| 294 | + adapter._erase() |
| 295 | + adapter.esp.erase_flash.assert_not_called() |
| 296 | + validate.side_effect = None |
| 297 | + with self.assertRaisesRegex(ValueError, "complete flash erase"): |
| 298 | + adapter._erase() |
| 299 | + self.assertFalse(adapter.erased) |
| 300 | + adapter.esp.flash_md5sum.assert_called_once_with(0, 0x1000000) |
| 301 | + |
| 302 | + async def test_esp_write_retains_exact_loader_and_never_adds_force_or_reset_flags(self): |
| 303 | + raw = b"host-only firmware bytes" |
| 304 | + validate = mock.Mock() |
| 305 | + adapter = HARDWARE._EspAdapter(binding(), self.root, validate) |
| 306 | + adapter._check = mock.Mock() |
| 307 | + adapter.erased = True |
| 308 | + adapter.esp = SimpleNamespace(_port=SimpleNamespace(is_open=True), |
| 309 | + flash_md5sum=mock.Mock(return_value=hashlib.md5(raw).hexdigest())) |
| 310 | + tool = SimpleNamespace(main=mock.Mock()) |
| 311 | + with mock.patch.dict(sys.modules, {"esptool": tool}): |
| 312 | + adapter._write(0, raw, "host-input.bin") |
| 313 | + argv = tool.main.call_args.args[0] |
| 314 | + self.assertEqual(tool.main.call_args.kwargs, {"esp": adapter.esp}) |
| 315 | + self.assertEqual(argv[argv.index("--before") + 1], "no_reset_no_sync") |
| 316 | + self.assertEqual(argv[argv.index("--after") + 1], "no_reset_stub") |
| 317 | + self.assertEqual(argv[argv.index("--connect-attempts") + 1], "1") |
| 318 | + self.assertEqual(argv[-2:], ["0x0", str(self.root / "host-input.bin")]) |
| 319 | + self.assertNotIn("--force", argv) |
| 320 | + self.assertNotIn("--erase-all", argv) |
| 321 | + self.assertNotIn("--encrypt", argv) |
| 322 | + self.assertEqual(validate.call_count, 2) |
| 323 | + |
| 324 | + async def test_esp_failed_read_keeps_real_bytes_from_becoming_candidate_evidence(self): |
| 325 | + adapter = HARDWARE._EspAdapter(binding(), self.root, mock.Mock()) |
| 326 | + adapter._check = mock.Mock() |
| 327 | + adapter.esp = SimpleNamespace(flash_md5sum=mock.Mock(return_value=hashlib.md5(b"good").hexdigest()), |
| 328 | + read_flash=mock.Mock(return_value=b"evil")) |
| 329 | + with self.assertRaisesRegex(ValueError, "actual flash read"): |
| 330 | + adapter._read(0, 4) |
| 331 | + |
| 332 | + async def test_candidate_byte_change_prevents_esp_write_even_after_successful_erase(self): |
| 333 | + adapter = HARDWARE._EspAdapter(binding(), self.root, |
| 334 | + mock.Mock(side_effect=ValueError("changed candidate"))) |
| 335 | + adapter._check = mock.Mock() |
| 336 | + adapter.erased = True |
| 337 | + tool = SimpleNamespace(main=mock.Mock()) |
| 338 | + with mock.patch.dict(sys.modules, {"esptool": tool}), self.assertRaisesRegex(ValueError, "changed candidate"): |
| 339 | + adapter._write(0, b"new", "unadmitted.bin") |
| 340 | + tool.main.assert_not_called() |
| 341 | + self.assertFalse((self.root / "unadmitted.bin").exists()) |
| 342 | + |
| 343 | + async def test_cancelled_ble_command_bounds_disconnect_even_when_backend_hangs(self): |
| 344 | + import _pble_central |
| 345 | + import target_smoke |
| 346 | + started = asyncio.Event() |
| 347 | + never = asyncio.Event() |
| 348 | + command_count = [0] |
| 349 | + async def send(*args, **kwargs): |
| 350 | + command_count[0] += 1 |
| 351 | + if command_count[0] == 2: |
| 352 | + started.set() |
| 353 | + await never.wait() |
| 354 | + return SimpleNamespace(payload=b"\0") |
| 355 | + central = SimpleNamespace(send_cmd=send, disconnect=mock.AsyncMock(side_effect=never.wait), |
| 356 | + events=[], confirm_caps_mtu=mock.Mock(), is_connected=True) |
| 357 | + real_wait_for = asyncio.wait_for |
| 358 | + bounded_cleanup = [] |
| 359 | + async def bounded(awaitable, timeout): |
| 360 | + bounded_cleanup.append(timeout) |
| 361 | + return await real_wait_for(awaitable, min(timeout, 0.01)) |
| 362 | + with mock.patch.object(HARDWARE, "_usb_exact"), \ |
| 363 | + mock.patch.object(HARDWARE.importlib.metadata, "version", return_value="3.0.2"), \ |
| 364 | + mock.patch.object(_pble_central.PbleCentral, "connect", return_value=central), \ |
| 365 | + mock.patch.object(target_smoke, "parse_caps", return_value={"auto_run": "0", "mtu": "247"}), \ |
| 366 | + mock.patch.object(target_smoke, "validate_caps"), \ |
| 367 | + mock.patch.object(HARDWARE.asyncio, "wait_for", side_effect=bounded): |
| 368 | + task = asyncio.create_task(self.backend._ble_command("pass")) |
| 369 | + await real_wait_for(started.wait(), 0.2) |
| 370 | + task.cancel() |
| 371 | + with self.assertRaises(asyncio.CancelledError): |
| 372 | + await real_wait_for(task, 0.2) |
| 373 | + self.assertTrue(bounded_cleanup, "BLE teardown never used a bounded wait") |
| 374 | + self.assertTrue(all(0 < seconds <= 5 for seconds in bounded_cleanup)) |
| 375 | + |
284 | 376 |
|
285 | 377 | if __name__ == "__main__": |
286 | 378 | unittest.main(verbosity=2) |
0 commit comments