Skip to content

Commit fb0eb69

Browse files
committed
[red] cover native USB and runtime observation lifecycle
Signed-off-by: Viwat Vchirawongkwin <viwat.v@chula.ac.th>
1 parent e68a499 commit fb0eb69

1 file changed

Lines changed: 109 additions & 0 deletions

File tree

‎tests/firmware_tests/host/test_v061_workspace_hardware.py‎

Lines changed: 109 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,10 @@
99
from pathlib import Path
1010
import struct
1111
import sys
12+
import tempfile
13+
from types import SimpleNamespace
1214
import unittest
15+
from unittest import mock
1316

1417
ROOT = Path(__file__).resolve().parents[3]
1518
HIL = ROOT / "tests/firmware_tests/hil"
@@ -172,6 +175,112 @@ def test_nonblank_precondition_is_explicitly_incompatible_without_full_device_ze
172175
with self.subTest(block_size=invalid), self.assertRaises(ValueError):
173176
fn(invalid)
174177

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+
175284

176285
if __name__ == "__main__":
177286
unittest.main(verbosity=2)

0 commit comments

Comments
 (0)