167 lines
7.2 KiB
Python
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")
|