Fix live multi-turn: pass the resolved drug, stop did-you-mean garbage

apps/ai-service/tests/test_bedrock_converse.py

@@ -0,0 +1,147 @@
+"""The Converse adapter must translate provider failure into the domain error,
+isolate the JSON envelope the API cannot enforce, and never leak an SDK type.
+
+No network: a stub client stands in for `bedrock-runtime`. The grounding check
+that actually guards correctness lives in `rag.grounding` and is tested there;
+here we prove only the adapter's envelope and failure contract.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from adapters.bedrock_converse import (
+    BedrockConverseAnswerGenerator,
+    BedrockCohereReranker,
+    RerankUnavailable,
+    _extract_json,
+)
+from rag.ports import AnswerGenerationUnavailable
+
+
+def _converse_reply(text: str, stop_reason: str = "end_turn") -> dict:
+    return {
+        "stopReason": stop_reason,
+        "output": {"message": {"content": [{"text": text}]}},
+        "usage": {"inputTokens": 10, "outputTokens": 5},
+    }
+
+
+class _Client:
+    def __init__(self, reply: dict) -> None:
+        self._reply = reply
+        self.calls: list[dict] = []
+
+    def converse(self, **kwargs):
+        self.calls.append(kwargs)
+        return self._reply
+
+
+def _payload(answer: str = "Liều 500 mg [1]", sufficient: bool = True) -> str:
+    return json.dumps({"answer": answer, "evidence_sufficient": sufficient}, ensure_ascii=False)
+
+
+def test_returns_the_models_json_on_success():
+    client = _Client(_converse_reply(_payload()))
+    gen = BedrockConverseAnswerGenerator(client=client, model_id="deepseek.v3.2")
+
+    raw = gen.generate("system", "user", {"type": "object"})
+
+    parsed = json.loads(raw)
+    assert parsed["answer"] == "Liều 500 mg [1]"
+    assert parsed["evidence_sufficient"] is True
+    # The prompt carries the schema and a JSON-only directive to the model.
+    sent = client.calls[0]["messages"][0]["content"][0]["text"]
+    assert "JSON" in sent
+
+
+def test_strips_a_markdown_fence_the_api_cannot_forbid():
+    fenced = f"```json\n{_payload()}\n```"
+    gen = BedrockConverseAnswerGenerator(client=_Client(_converse_reply(fenced)))
+
+    parsed = json.loads(gen.generate("s", "u", {}))
+
+    assert parsed["answer"] == "Liều 500 mg [1]"
+
+
+def test_extracts_json_when_the_model_adds_prose_around_it():
+    noisy = f"Đây là câu trả lời: {_payload()} Hết."
+    assert json.loads(_extract_json(noisy))["evidence_sufficient"] is True
+
+
+def test_a_filtered_stop_reason_is_an_outage_not_an_answer():
+    client = _Client(_converse_reply("", stop_reason="content_filtered"))
+    gen = BedrockConverseAnswerGenerator(client=client)
+
+    with pytest.raises(AnswerGenerationUnavailable):
+        gen.generate("s", "u", {})
+
+
+def test_empty_text_raises_rather_than_returning_blank():
+    gen = BedrockConverseAnswerGenerator(client=_Client(_converse_reply("   ")))
+
+    with pytest.raises(AnswerGenerationUnavailable):
+        gen.generate("s", "u", {})
+
+
+def test_real_botocore_client_error_becomes_the_domain_error():
+    botocore_exceptions = pytest.importorskip("botocore.exceptions")
+
+    class _Refusing:
+        def converse(self, **kwargs):
+            raise botocore_exceptions.ClientError(
+                {"Error": {"Code": "AccessDeniedException", "Message": "denied"}},
+                "Converse",
+            )
+
+    gen = BedrockConverseAnswerGenerator(client=_Refusing())
+
+    with pytest.raises(AnswerGenerationUnavailable):
+        gen.generate("s", "u", {})
+
+
+# --- reranker -----------------------------------------------------------------
+
+
+class _RerankBody:
+    def __init__(self, payload: dict) -> None:
+        self._data = json.dumps(payload).encode("utf-8")
+
+    def read(self) -> bytes:
+        return self._data
+
+
+class _RerankClient:
+    def __init__(self, payload: dict) -> None:
+        self._payload = payload
+
+    def invoke_model(self, **kwargs):
+        return {"body": _RerankBody(self._payload)}
+
+
+def test_rerank_returns_indices_most_relevant_first():
+    client = _RerankClient({"results": [{"index": 2}, {"index": 0}, {"index": 1}]})
+    reranker = BedrockCohereReranker(client=client)
+
+    order = reranker.rerank("chống chỉ định", ["a", "b", "c"])
+
+    assert order == [2, 0, 1]
+
+
+def test_rerank_raises_so_the_caller_keeps_original_order():
+    botocore_exceptions = pytest.importorskip("botocore.exceptions")
+
+    class _Refusing:
+        def invoke_model(self, **kwargs):
+            raise botocore_exceptions.ClientError(
+                {"Error": {"Code": "AccessDeniedException", "Message": "denied"}},
+                "InvokeModel",
+            )
+
+    with pytest.raises(RerankUnavailable):
+        BedrockCohereReranker(client=_Refusing()).rerank("q", ["a", "b"])
+
+
+def test_rerank_of_nothing_is_empty():
+    assert BedrockCohereReranker(client=_RerankClient({})).rerank("q", []) == []