|
9 | 9 | from pathlib import Path |
10 | 10 | import struct |
11 | 11 | import sys |
| 12 | +import tempfile |
| 13 | +from types import SimpleNamespace |
12 | 14 | import unittest |
| 15 | +from unittest import mock |
13 | 16 |
|
14 | 17 | ROOT = Path(__file__).resolve().parents[3] |
15 | 18 | HIL = ROOT / "tests/firmware_tests/hil" |
@@ -172,6 +175,112 @@ def test_nonblank_precondition_is_explicitly_incompatible_without_full_device_ze |
172 | 175 | with self.subTest(block_size=invalid), self.assertRaises(ValueError): |
173 | 176 | fn(invalid) |
174 | 177 |
|
| 178 | + def test_known_native_application_is_not_mistaken_for_wrong_loader(self): |
| 179 | + self.api("validate_binding") |
| 180 | + application = binding()["application_usb"] |
| 181 | + loader = dict(application, vid=0x303a, pid=0x1001) |
| 182 | + with mock.patch.object(HARDWARE, "_ports", return_value=[application]): |
| 183 | + self.assertFalse(HARDWARE._usb_exact(loader, absent_ok=True, alternate=application)) |
| 184 | + wrong = dict(application, serial_number="OTHER-TARGET") |
| 185 | + with mock.patch.object(HARDWARE, "_ports", return_value=[wrong]), self.assertRaises(ValueError): |
| 186 | + HARDWARE._usb_exact(loader, absent_ok=True, alternate=application) |
| 187 | + |
| 188 | + def test_duplicate_serial_alias_must_be_idle_before_open(self): |
| 189 | + self.api("validate_binding") |
| 190 | + selected = binding()["application_usb"] |
| 191 | + alias = dict(selected, port="/dev/cu.duplicate-test-alias") |
| 192 | + with mock.patch.object(HARDWARE, "_ports", return_value=[selected, alias]), \ |
| 193 | + mock.patch.object(HARDWARE.subprocess, "run", return_value=SimpleNamespace(returncode=0, stdout=b"occupied")) as run: |
| 194 | + with self.assertRaises(ValueError): |
| 195 | + HARDWARE._usb_exact(selected, idle=True) |
| 196 | + self.assertEqual(run.call_args.args[0], ["/usr/sbin/lsof", selected["port"], alias["port"]]) |
| 197 | + |
| 198 | + |
| 199 | +class WorkspaceHardwareLifecycleTests(unittest.IsolatedAsyncioTestCase): |
| 200 | + def setUp(self): |
| 201 | + self.assertIsNotNone(HARDWARE) |
| 202 | + self.temporary = tempfile.TemporaryDirectory(prefix="pyble-hardware-host-") |
| 203 | + self.addCleanup(self.temporary.cleanup) |
| 204 | + self.root = Path(self.temporary.name) |
| 205 | + self.backend = HARDWARE.WorkspaceHardware(binding(), repo_root=self.root, candidate_dir=self.root) |
| 206 | + self.backend.work_dir = self.root |
| 207 | + self.backend.kind = "erased-media-first-boot" |
| 208 | + |
| 209 | + async def test_boot_cannot_precede_complete_pre_read_or_repeat(self): |
| 210 | + self.backend.adapter = SimpleNamespace(boot=mock.AsyncMock(return_value=b"first boot")) |
| 211 | + for phase in ("new", "prepared", "pre-reading", "booted", "observed"): |
| 212 | + self.backend.phase = phase |
| 213 | + with self.subTest(phase=phase), self.assertRaises(ValueError): |
| 214 | + await self.backend.boot() |
| 215 | + self.backend.adapter.boot.assert_not_awaited() |
| 216 | + self.backend.phase = "pre-read" |
| 217 | + self.assertEqual(await self.backend.boot(), b"first boot") |
| 218 | + self.assertEqual(self.backend.phase, "booted") |
| 219 | + with self.assertRaises(ValueError): |
| 220 | + await self.backend.boot() |
| 221 | + self.backend.adapter.boot.assert_awaited_once() |
| 222 | + |
| 223 | + async def test_failed_actual_read_does_not_authorize_boot(self): |
| 224 | + self.backend.phase = "prepared" |
| 225 | + self.backend.adapter = SimpleNamespace(read_flash=mock.AsyncMock(return_value=b"short"), |
| 226 | + boot=mock.AsyncMock()) |
| 227 | + with self.assertRaises(ValueError): |
| 228 | + await self.backend.read_media(0x210000, 0xdf0000) |
| 229 | + with self.assertRaises(ValueError): |
| 230 | + await self.backend.boot() |
| 231 | + self.backend.adapter.boot.assert_not_awaited() |
| 232 | + |
| 233 | + async def test_wrong_transport_or_repeated_observation_never_contacts_runtime(self): |
| 234 | + self.backend.phase = "booted" |
| 235 | + self.backend._ble_command = mock.AsyncMock() |
| 236 | + self.backend._usb_command = mock.AsyncMock() |
| 237 | + for challenge, transport in (("a" * 32, "usb-repl"), ("A" * 32, "pble-run")): |
| 238 | + with self.assertRaises(ValueError): |
| 239 | + await self.backend.observe(challenge, transport) |
| 240 | + self.backend._ble_command.assert_not_awaited() |
| 241 | + self.backend._usb_command.assert_not_awaited() |
| 242 | + |
| 243 | + async def test_wave_hello_validates_chip_not_board_profile_token(self): |
| 244 | + import _pble_central |
| 245 | + import target_smoke |
| 246 | + self.backend.binding["profile_id"] = "waveshare-esp32-s3-lcd-147b" |
| 247 | + central = SimpleNamespace(send_cmd=mock.AsyncMock(return_value=SimpleNamespace(payload=b"\0")), |
| 248 | + disconnect=mock.AsyncMock()) |
| 249 | + with mock.patch.object(HARDWARE, "_usb_exact"), \ |
| 250 | + mock.patch.object(HARDWARE.importlib.metadata, "version", return_value="3.0.2"), \ |
| 251 | + mock.patch.object(_pble_central.PbleCentral, "connect", return_value=central), \ |
| 252 | + mock.patch.object(target_smoke, "validate_caps", side_effect=RuntimeError("stop after caps")) as validate: |
| 253 | + with self.assertRaisesRegex(RuntimeError, "stop after caps"): |
| 254 | + await self.backend._ble_command("pass") |
| 255 | + self.assertEqual(validate.call_args.args[1], "esp32-s3") |
| 256 | + central.disconnect.assert_awaited_once() |
| 257 | + |
| 258 | + async def test_close_never_resets_or_implicitly_boots(self): |
| 259 | + adapter = SimpleNamespace(close=mock.AsyncMock(), boot=mock.AsyncMock()) |
| 260 | + self.backend.adapter = adapter |
| 261 | + await self.backend.close() |
| 262 | + await self.backend.close() |
| 263 | + adapter.boot.assert_not_awaited() |
| 264 | + self.assertEqual(self.backend.phase, "closed") |
| 265 | + |
| 266 | + async def test_raw_repl_reentry_explicitly_exits_previous_raw_mode_without_soft_reset(self): |
| 267 | + writes = [] |
| 268 | + class Port: |
| 269 | + def open(self): |
| 270 | + pass |
| 271 | + def close(self): |
| 272 | + pass |
| 273 | + def write(self, raw): |
| 274 | + writes.append(raw) |
| 275 | + raise OSError("stop after entry bytes") |
| 276 | + serial = SimpleNamespace(Serial=lambda **kwargs: Port()) |
| 277 | + with mock.patch.dict(sys.modules, {"serial": serial}), \ |
| 278 | + mock.patch.object(HARDWARE.importlib.metadata, "version", return_value="3.5"), \ |
| 279 | + mock.patch.object(HARDWARE, "_usb_exact"): |
| 280 | + with self.assertRaisesRegex(OSError, "stop after entry bytes"): |
| 281 | + self.backend._usb_command_sync("pass", False) |
| 282 | + self.assertEqual(writes, [b"\x03\x03\x02\x01"]) |
| 283 | + |
175 | 284 |
|
176 | 285 | if __name__ == "__main__": |
177 | 286 | unittest.main(verbosity=2) |
0 commit comments