"""Offline tests for the legacy PTZ frame handoff using the actual server functions.""" from __future__ import annotations import ast from contextlib import nullcontext from functools import wraps from pathlib import Path from types import SimpleNamespace from typing import NamedTuple import unittest ROOT = Path(__file__).resolve().parent / 'ptz_tracker_modular' def definitions(file, names, env): path = ROOT / file tree = ast.parse(path.read_text(encoding='utf-8')) definitions = [node for node in tree.body if getattr(node, 'name', None) in names] future = tree.body[0] if isinstance(tree.body[0], ast.ImportFrom) and tree.body[0].module == '__future__' else None exec(compile(ast.Module(body=([future] if future else []) + definitions, type_ignores=[]), str(path), 'exec'), env) class FrameHandoffTests(unittest.TestCase): def setUp(self): self.source = object() self.frame = object() self.utc, self.mono = 100., 50. self.owner = (0, 3, 99., 1) self.st = {'mode': 'TRACK', 'tracking_active': True} self.st.update(owner=self.owner) self.ptz = [] self.tracker = [] self.saved = None self.env = dict( NamedTuple=NamedTuple, _visual_source=self.source, state=SimpleNamespace(ptz_states={0: self.st}), time=SimpleNamespace(time=lambda: self.utc, monotonic=lambda: self.mono), visual_control=SimpleNamespace(control_lock=lambda cam: nullcontext(), owner=lambda st: st['owner'], enabled=lambda: True, VisualSample=lambda owner, seq, at, result: SimpleNamespace(owner=owner, source_seq=seq, captured_at=at, result=result), retain=self.retain, latest=lambda *args: self.saved), visual_control_probe=SimpleNamespace(trace_feed_update=lambda f:f, call_tracker_update=lambda update,*args,**kwargs: update(*args,**kwargs)), visual_tracker_manager=SimpleNamespace(update=self.update_tracker), config=SimpleNamespace(), _visual_feed_is_active=lambda *args: True, _store_visual_feed_result=lambda *args: None, postprocess_control=lambda *args,**kw:self.ptz.append((args,kw)), ) definitions('streaming.py', ('_VisualReceipt','_visual_receipt_current','_update_visual_feed', '_prepare_visual_inference_item','_postprocess_inference_item'), self.env) def retain(self, camera, frame, sample): self.saved = frame, sample def update_tracker(self, camera, frame, source_seq): self.tracker.append((camera, frame, source_seq)) return SimpleNamespace(ok=True) def visual(self, **overrides): fields = dict(source=self.source, owner=self.owner, utc=100., monotonic=50.) fields.update(overrides) receipt = self.env['_VisualReceipt'](**fields) self.env['_update_visual_feed'](0, self.frame, 1, receipt=receipt) def test_recent_frame_centers_with_original_decode_time(self): self.utc += .11 self.mono += .11 self.visual() self.assertEqual(self.tracker, [(0,self.frame,1)]) self.assertTrue(self.ptz[0][1]['visual_only']) self.assertEqual(self.ptz[0][1]['visual_sample'].captured_at, 100.) def test_stale_foreign_and_future_frames_do_not_reach_tracker(self): for override in ({'monotonic':49.7}, {'utc':100.2}, {'source':object()}, {'owner':(0,2,99.,1)}): with self.subTest(override=override): self.visual(**override) self.assertEqual(self.tracker, []) self.assertEqual(self.ptz, []) def test_frame_aging_during_tracker_update_is_not_sent_to_ptz(self): def update(*args, **kw): self.mono += .3 return self.update_tracker(*args, **kw) self.env['visual_tracker_manager'].update = update self.visual() self.assertEqual(len(self.tracker), 1) self.assertEqual(self.ptz, []) def test_paired_detection_keeps_image_and_rejects_late_result(self): self.visual() queued = (0, object(), True, 2, SimpleNamespace(), 51.) cam, frame, ptz, seq, future, _ = self.env['_prepare_visual_inference_item'](queued) self.assertIs(frame, self.frame) self.assertEqual(seq, 1) self.utc += .4 self.mono += .4 self.env['_postprocess_inference_item'](cam, frame, 'legacy results', ptz, seq, future) self.assertEqual(self.ptz[-1][0][2], 'legacy results') self.assertIs(self.ptz[-1][1]['visual_sample'], self.saved[1]) self.mono += .3 self.env['_postprocess_inference_item'](cam, frame, 'late results', ptz, seq, future) self.assertEqual(len(self.ptz), 2) def test_paired_detection_discarded_after_reconnect(self): self.visual() cam, frame, ptz, seq, future, _ = self.env['_prepare_visual_inference_item']( (0, object(), True, 2, SimpleNamespace(), 51.)) self.env['_visual_source'] = object() self.env['_postprocess_inference_item'](cam, frame, 'legacy results', ptz, seq, future) self.assertEqual(len(self.ptz), 1) def test_unpaired_detector_results_keep_legacy_entry_point(self): post = self.env['_postprocess_inference_item'] for ptz in (True,False): post(0, self.frame, 'legacy results', ptz, 1, SimpleNamespace()) self.assertEqual(self.ptz[-1], ((0, self.frame, 'legacy results', ptz, 1), {})) def test_decoder_busy_branch_uses_original_receipt_on_both_preview_paths(self): class StopProbe(Exception): pass async def stop_after_connection(delay): raise StopProbe class Socket: async def __aenter__(self): return self async def __aexit__(self, *exc): pass async def __aiter__(self): yield b'\x01\x00\x00\x17' for preview in (False, True): with self.subTest(preview=preview): seen, errors, decoded = [], [], [] self.utc, self.mono = 100., 50. self.st.update(proc_busy=True, last_source_seq=0) def image_decode(buffer, mode): decoded.append(1) return self.frame def publish(*args, **kwargs): self.utc, self.mono = 100.2, 50.2 self.env.update( websockets=SimpleNamespace(connect=lambda *args,**kwargs:Socket()), asyncio=SimpleNamespace(sleep=stop_after_connection), logger=SimpleNamespace(info=lambda *args:None, error=lambda *args:errors.append(args)), config=SimpleNamespace(CAMERA_CONFIG={0:{}}, PTZ_CAM_IDS=(0,), DROP_DECODE_WHEN_BUSY=True, CPP_WS_URI='offline'), cv2=SimpleNamespace(imdecode=image_decode,IMREAD_COLOR=1), np=SimpleNamespace(frombuffer=lambda data,dtype:data,uint8=int), _cpp_stream_map_logged=set(), _resolve_cpp_cam_id=int, ensure_runtime_state_for_camera=lambda *args:None, _has_recent_video_client=lambda *args:True, _frontend_raw_preview_due=lambda *args:preview, _publish_frontend_raw_preview=publish, _target_predecode_fps=lambda *args:0, _feed_visual_tracker_frame=lambda *args,**kw:seen.append((args,kw['receipt'],self.env['_visual_source'])), ) self.env['time'].perf_counter=lambda:50. self.env['state'].detected_cameras={0} definitions('streaming.py', ('cpp_ws_loop',), self.env) with self.assertRaises(StopProbe): self.env['cpp_ws_loop']().send(None) self.assertFalse(errors) self.assertEqual(len(decoded),1) self.assertEqual(len(seen),1) args, receipt, source = seen[0] self.assertEqual(args, (0,self.frame,self.st,1)) self.assertIs(receipt.source, source) self.assertEqual((receipt.utc, receipt.monotonic), (100.,50.)) self.assertIsNone(self.env['_visual_source']) def test_probe_decorators_forward_receipt(self): got = [] env = dict(wraps=wraps, _perf=lambda:0., _wall=lambda:100., _context=SimpleNamespace(), _safe_record=lambda *args,**kwargs:None) definitions('visual_control_probe.py', ('trace_enqueue','trace_feed_update'), env) def enqueue(camera, frame, st, source_seq, *, receipt): got.append(receipt) def update(camera, frame, source_seq, captured_at=None, *, receipt): got.append(receipt) env['trace_enqueue'](enqueue)(0, self.frame, {}, 1, receipt=self.source) env['trace_feed_update'](update)(0, self.frame, 1, 100., receipt=self.source) self.assertEqual(got, [self.source,self.source]) if __name__ == '__main__': unittest.main(verbosity=2)