Files
zyt/app/tests/test_cloud_transcription_cycles.py
2026-11-12 16:11:43 +08:00

167 lines
7.2 KiB
Python

"""Exercise persisted cloud captions across redials using the real lifecycle worker."""
from __future__ import annotations
import logging
from itertools import count
from queue import Queue
from threading import Event
from types import MethodType
from unittest.mock import Mock
import pytest
from test_cloud_transcription_bridge import (
SIMPLIFIED,
TIMESTAMP,
host,
segment_message,
transcription_result,
)
from doctor_workstation.video import window
from doctor_workstation.video.launcher import VideoCallRequest
from doctor_workstation.video.lifecycle import OrderedCallLifecycle
pytestmark = pytest.mark.skipif(not window.WEBENGINE_AVAILABLE, reason="optional QtWebEngine")
@pytest.fixture
def cycle_host():
record_ids = count(701)
repository = Mock()
repository.start_call.side_effect = lambda **_payload: {"call_record_id": next(record_ids)}
repository.start_call_transcription.return_value = True
repository.upsert_call_transcript_segments.return_value = True
repository.finish_call_transcription.return_value = True
request = VideoCallRequest(
sdk_app_id=1400123456, user_id="doctor_test", user_sig="test-ticket",
target_user_id="patient_test", diagnosis_id=123, patient_id=8,
)
item = host(
request=request, repository=repository, _start_requested=False,
open_im=True, call_ended=Mock(), _start_completed=Mock(),
start_acks=Queue(), transcription_acks=Queue(), release_storage=Event(),
)
item._lifecycle_factory = lambda: OrderedCallLifecycle(
request, repository, logging.getLogger(__name__),
)
item.lifecycle = item._lifecycle_factory()
item._lifecycles = [item.lifecycle]
for name in (
"_prepare_call_cycle", "_start_call_cycle", "_notify_start_completed",
"_on_lifecycle_started",
):
setattr(item, name, MethodType(getattr(window._EmbeddedVideoWindow, name), item))
# A worker may complete while its Qt signal remains queued for the UI thread.
item._start_completed.emit.side_effect = lambda *args: item.start_acks.put(args)
item._transcription_completed.emit.side_effect = lambda *args: item.transcription_acks.put(args)
try:
yield item
finally:
item.release_storage.set()
for lifecycle in item._lifecycles:
lifecycle.end("test-cleanup").result(timeout=2)
assert lifecycle.wait(2)
def start_cycle(item, session_id):
item._handle_bridge_message({"event": "call-start-request"})
acknowledgement = item.start_acks.get(timeout=2)
assert acknowledgement == (True,)
item._on_lifecycle_started(*acknowledgement)
item._handle_bridge_message({
"event": "transcription-start-request", "sessionId": session_id,
})
acknowledgement = item.transcription_acks.get(timeout=2)
assert acknowledgement[:4] == ("start", session_id, "", True)
item._on_transcription_completed(*acknowledgement)
item._live_ai.bind.assert_called_with(item.lifecycle.call_record_id, session_id)
item._page.runJavaScript.reset_mock()
item._live_ai.reset_mock()
return item.lifecycle
def assert_caption_ack(item, session_id, acknowledgement):
assert acknowledgement[:4] == ("segment", session_id, "cloud-segment-1", True)
item._on_transcription_completed(*acknowledgement)
assert transcription_result(item) == [
"segment", session_id, "cloud-segment-1", True, "",
{"segmentId": "cloud-segment-1", "speakerUserId": "patient_test",
"sourceText": SIMPLIFIED, "timestamp": TIMESTAMP, "isCompleted": True},
]
item._live_ai.changed.assert_called_once_with(session_id)
def test_three_calls_save_reused_segment_id_and_ack_simplified_captions(cycle_host):
item = cycle_host
for record_id, session_id in ((701, "tr-first"), (702, "tr-second"), (703, "tr-third")):
lifecycle = start_cycle(item, session_id)
assert lifecycle.call_record_id == record_id
item._handle_bridge_message(segment_message(sessionId=session_id))
acknowledgement = item.transcription_acks.get(timeout=2)
# Saving on the worker must finish before normalized text reaches the page.
item._page.runJavaScript.assert_not_called()
item._live_ai.changed.assert_not_called()
saved = item.repository.upsert_call_transcript_segments.call_args.kwargs
assert (saved["call_record_id"], saved["transcription_session_id"]) == (record_id, session_id)
assert saved["segments"][0]["text"] == SIMPLIFIED
assert saved["segments"][0]["segment_id"] == "cloud-segment-1"
assert_caption_ack(item, session_id, acknowledgement)
item._handle_bridge_message({"event": "transcription-stop", "sessionId": session_id})
acknowledgement = item.transcription_acks.get(timeout=2)
assert acknowledgement[:4] == ("stop", session_id, "", True)
item._on_transcription_completed(*acknowledgement)
item._handle_bridge_message({"event": "hangup"})
assert lifecycle.wait(2)
assert len({id(lifecycle) for lifecycle in item._lifecycles}) == 3
assert item.repository.upsert_call_transcript_segments.call_count == 3
assert [call.kwargs["call_record_id"] for call in item.repository.end_call.call_args_list] == [701, 702, 703]
@pytest.mark.parametrize("worker_finishes_before_redial", [False, True])
@pytest.mark.parametrize("storage_succeeds", [False, True])
def test_old_segment_ack_keeps_old_session_and_cannot_dirty_redial(
cycle_host, worker_finishes_before_redial, storage_succeeds,
):
item = cycle_host
entered = Event()
def save_segment(**payload):
if payload["call_record_id"] == 701:
entered.set()
if not worker_finishes_before_redial:
assert item.release_storage.wait(5), "test did not release the old write"
if not storage_succeeds:
raise RuntimeError("old call storage failure")
return True
item.repository.upsert_call_transcript_segments.side_effect = save_segment
previous = start_cycle(item, "tr-old")
item._handle_bridge_message(segment_message(sessionId="tr-old"))
assert entered.wait(2)
if worker_finishes_before_redial:
old_ack = item.transcription_acks.get(timeout=2)
item._handle_bridge_message({"event": "hangup"})
current = start_cycle(item, "tr-current")
assert current is not previous
if not worker_finishes_before_redial:
item.release_storage.set()
old_ack = item.transcription_acks.get(timeout=2)
assert old_ack[:4] == ("segment", "tr-old", "cloud-segment-1", storage_succeeds)
item._on_transcription_completed(*old_ack)
# The companion filters ACKs by this session; the host must never retag them.
assert transcription_result(item)[:4] == ["segment", "tr-old", "cloud-segment-1", storage_succeeds]
assert item.lifecycle is current
assert current.transcription_session_id == "tr-current"
assert not item._asr_partial
assert item._live_ai.mock_calls == []
item._handle_bridge_message(segment_message(sessionId="tr-current"))
assert_caption_ack(item, "tr-current", item.transcription_acks.get(timeout=2))
saved = item.repository.upsert_call_transcript_segments.call_args.kwargs
assert (saved["call_record_id"], saved["transcription_session_id"]) == (702, "tr-current")