Kansho/backend/tests/test_detect_learning.py

"""Transitional learning detect: senses from dialogue review, admin mode switch.

Fake detect/provider only. Run from backend/: python tests/test_detect_learning.py
"""
from __future__ import annotations

import os
import sys
from pathlib import Path
from unittest.mock import patch

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))

os.environ["KANSHO_FAKE_PROVIDER"] = "1"
os.environ["KANSHO_FAKE_DETECT"] = "1"

from fastapi.testclient import TestClient
from detect_learning import (
    cue_for_mention,
    excerpt_view,
    get_cue_decision,
    get_detect_operating_mode,
    get_sense,
    record_sense,
)
from dialogue_turn import visible_for_role
from identity_store import list_confirmed_identities
from main import app
from privacy_gateway import reset_debug


def expect(ok: bool, message: str) -> None:
    if not ok:
        raise SystemExit(f"FAIL: {message}")
    print(f"OK  {message}")


def status_ok(response, label: str) -> None:
    if response.status_code != 200:
        detail = response.json() if response.headers.get("content-type", "").startswith("application/json") else {}
        code = detail.get("detail", {}).get("code") if isinstance(detail, dict) else None
        expect(False, f"{label} HTTP {response.status_code} {code or ''}".strip())
    expect(True, label)


def header(token: str) -> dict:
    return {"X-Auth-Token": token}


def open_conv(client: TestClient, headers: dict) -> str:
    space = client.post("/api/journal/spaces", headers=headers, json={"title": "Alltag"})
    day = client.post(
        f"/api/journal/spaces/{space.json()['id']}/days",
        headers=headers,
        json={"calendar_date": "2026-09-08"},
    )
    conv = client.post(
        f"/api/journal/days/{day.json()['day']['id']}/conversations",
        headers=headers,
        json={"title": "Gespräch"},
    )
    return conv.json()["id"]


def main() -> None:
    reset_debug()
    with TestClient(app) as client:
        setup = client.post(
            "/api/auth/setup",
            json={"email": "lars@example.test", "name": "Lars", "password": "test-pass"},
        )
        headers = header(setup.json()["token"])
        profile_id = setup.json()["profile_id"]

        providers = client.get("/api/admin/providers", headers=headers)
        expect(providers.status_code == 200, "providers status")
        expect(providers.json()["detect_operating_mode"] == "semantic", "default detect mode is semantic")
        expect(get_detect_operating_mode() == "semantic", "store default is semantic")

        bad = client.put("/api/admin/providers/detect-mode", headers=headers, json={"mode": "wordlist"})
        expect(bad.status_code == 400, "invalid detect mode is rejected")

        conv_semantic = open_conv(client, headers)
        semantic_turn = client.post(
            f"/api/journal/conversations/{conv_semantic}/turn",
            headers=headers,
            json={"body": "Anna kam vorbei."},
        )
        status_ok(semantic_turn, "semantic turn")
        expect(not semantic_turn.json().get("pending_mask_review"), "semantic mode does not pause for review")
        expect(any(item.get("role") == "assistant" for item in semantic_turn.json().get("messages") or []), "semantic turn gets an assistant")

        switched = client.put("/api/admin/providers/detect-mode", headers=headers, json={"mode": "learning"})
        status_ok(switched, "switch to learning")
        expect(switched.json()["detect_operating_mode"] == "learning", "learning mode persisted")

        conv = open_conv(client, headers)
        paused = client.post(
            f"/api/journal/conversations/{conv}/turn",
            headers=headers,
            json={"body": "Anna kam vorbei."},
        )
        status_ok(paused, "learning pause")
        review = paused.json().get("pending_mask_review") or {}
        expect(bool(review.get("id")), "learning mode returns a review id")
        expect(paused.json().get("assistant") is None, "paused turn has no assistant")
        candidates = review.get("candidates") or []
        anna = next((item for item in candidates if item.get("text") == "Anna"), None)
        expect(anna is not None, "Anna is a review candidate")
        hidden = visible_for_role({"pending_mask_review": review, "trace": {"egress": "x"}}, "user")
        expect("pending_mask_review" in hidden, "users still receive the mask review")
        expect("trace" not in hidden, "users do not receive the detect trace")

        reloaded = client.get(f"/api/journal/conversations/{conv}", headers=headers)
        expect(reloaded.json().get("pending_mask_review", {}).get("id") == review["id"], "pending review survives reload")

        missing = client.post(
            f"/api/journal/conversations/{conv}/turn/review",
            headers=headers,
            json={"review_id": "missing", "decisions": []},
        )
        expect(missing.status_code == 404, "unknown review is gone")

        identity = client.post(
            f"/api/journal/conversations/{conv}/turn/review",
            headers=headers,
            json={
                "review_id": review["id"],
                "decisions": [{"id": anna["id"], "decision": "identity"}],
            },
        )
        status_ok(identity, "identity review")
        expect(not identity.json().get("pending_mask_review"), "review continue clears the pause")
        expect(any(item.get("role") == "assistant" for item in identity.json().get("messages") or []), "continue produces an assistant")
        confirmed = list_confirmed_identities(profile_id)
        expect(any((item.get("canonical_label") or "").casefold() == "anna" for item in confirmed), "identity review confirms the registry")
        sense = get_sense(profile_id, "Anna")
        expect(sense["identity_hits"] >= 1 and not sense["ambiguous"], "Anna is identity-only")

        second = client.post(
            f"/api/journal/conversations/{conv}/turn",
            headers=headers,
            json={"body": "Anna hat später angerufen."},
        )
        status_ok(second, "second Anna turn")
        expect(not second.json().get("pending_mask_review"), "identity-only spelling skips the popup")

        food_conv = open_conv(client, headers)
        food = client.post(
            f"/api/journal/conversations/{food_conv}/turn",
            headers=headers,
            json={"body": "Hanna aß mit uns."},
        )
        status_ok(food, "hanna pause")
        food_review = food.json().get("pending_mask_review") or {}
        food_candidates = food_review.get("candidates") or []
        hanna = next((item for item in food_candidates if item.get("text") == "Hanna"), None)
        expect(hanna is not None, "Hanna is a review candidate")
        declined = client.post(
            f"/api/journal/conversations/{food_conv}/turn/review",
            headers=headers,
            json={
                "review_id": food_review["id"],
                "decisions": [{"id": hanna["id"], "decision": "not_identity"}],
            },
        )
        status_ok(declined, "not_identity review")
        expect(not any((item.get("canonical_label") or "").casefold() == "hanna" for item in list_confirmed_identities(profile_id)), "not_identity does not confirm Hanna")
        expect(get_sense(profile_id, "Hanna")["non_identity_hits"] >= 1, "not_identity records a sense")
        hanna_again = client.post(
            f"/api/journal/conversations/{food_conv}/turn",
            headers=headers,
            json={"body": "Hanna aß mit uns."},
        )
        status_ok(hanna_again, "second Hanna turn")
        expect(not hanna_again.json().get("pending_mask_review"), "known non-identity skips the popup")

        record_sense(profile_id, "Clarissa", identity=True)
        record_sense(profile_id, "Clarissa", identity=False)
        expect(get_sense(profile_id, "Clarissa")["ambiguous"], "both senses mark Clarissa as ambiguous")
        amb_conv = open_conv(client, headers)
        with patch("detect_learning.try_local_passage_decision", return_value="not_identity"):
            amb = client.post(
                f"/api/journal/conversations/{amb_conv}/turn",
                headers=headers,
                json={"body": "Clarissa lag auf dem Tisch."},
            )
        status_ok(amb, "ambiguous local passage")
        expect(not amb.json().get("pending_mask_review"), "local passage can finish without a popup")
        expect(any(item.get("role") == "assistant" for item in amb.json().get("messages") or []), "local passage still generates")

        kin_conv = open_conv(client, headers)
        kin = client.post(
            f"/api/journal/conversations/{kin_conv}/turn",
            headers=headers,
            json={"body": "Ich war mit meinem Sohn Leon im Park."},
        )
        status_ok(kin, "kinship Leon pause")
        kin_review = kin.json().get("pending_mask_review") or {}
        kin_names = [item.get("text") for item in kin_review.get("candidates") or []]
        expect("Leon" in kin_names, "Sohn Leon is offered even when Detect does not report it")
        leon = next((item for item in kin_review.get("candidates") or [] if item.get("text") == "Leon"), None)
        expect(leon is not None, "Leon candidate id is present")
        kin_done = client.post(
            f"/api/journal/conversations/{kin_conv}/turn/review",
            headers=headers,
            json={
                "review_id": kin_review["id"],
                "decisions": [{"id": leon["id"], "decision": "identity"}],
            },
        )
        status_ok(kin_done, "Leon identity review")
        kin_again = client.post(
            f"/api/journal/conversations/{kin_conv}/turn",
            headers=headers,
            json={"body": "Ich war mit meinem Sohn Leon im Park."},
        )
        status_ok(kin_again, "second Leon turn")
        expect(not kin_again.json().get("pending_mask_review"), "confirmed Sohn Leon skips the popup")

        sushi_conv = open_conv(client, headers)
        sushi = client.post(
            f"/api/journal/conversations/{sushi_conv}/turn",
            headers=headers,
            json={
                "body": (
                    "Gestern bin ich mit meiner Frau Sushi und meinem Sohn Rohan "
                    "Sushi essen gegangen. Das Restaurant hat mich dabei total beeindruckt."
                )
            },
        )
        status_ok(sushi, "homonym sentence pause")
        sushi_names = [item.get("text") for item in (sushi.json().get("pending_mask_review") or {}).get("candidates") or []]
        expect("Rohan" in sushi_names, "Rohan from Sohn is a candidate")
        expect("Sushi" in sushi_names, "Sushi from Frau is a candidate")
        expect("Restaurant" not in sushi_names, "plain Restaurant is not kinship-offered")
        sushi_hits = [
            item
            for item in (sushi.json().get("pending_mask_review") or {}).get("candidates") or []
            if item.get("text") == "Sushi"
        ]
        expect(len(sushi_hits) >= 2, "both Sushi mentions are offered")
        expect(
            sushi_hits[0].get("highlight_start") != sushi_hits[1].get("highlight_start"),
            "the two Sushi mentions highlight different offsets",
        )
        for item in sushi_hits:
            excerpt = item.get("excerpt") or ""
            start = item.get("highlight_start")
            end = item.get("highlight_end")
            expect(excerpt[start:end] == "Sushi", "highlight covers the Sushi token")

        homonym = (
            "Gestern bin ich mit meiner Frau Sushi und meinem Sohn Rohan "
            "Sushi essen gegangen."
        )
        first_at = homonym.index("Sushi")
        second_at = homonym.rindex("Sushi")
        first = excerpt_view(homonym, first_at, first_at + 5, "Sushi")
        second = excerpt_view(homonym, second_at, second_at + 5, "Sushi")
        expect(first["highlight_start"] < second["highlight_start"], "person Sushi sits left of dish Sushi")
        expect(first["excerpt"][first["highlight_start"]:first["highlight_end"]] == "Sushi", "first highlight is Sushi")
        expect(second["excerpt"][second["highlight_start"]:second["highlight_end"]] == "Sushi", "second highlight is Sushi")
        prefix = "SYSTEM\n"
        mapped = excerpt_view(
            homonym,
            len(prefix) + second_at,
            len(prefix) + second_at + 5,
            "Sushi",
            prefix + homonym,
        )
        expect(mapped["highlight_start"] == second["highlight_start"], "rendered detect offsets map to the dish Sushi")
        expect(cue_for_mention(homonym, first_at, first_at + 5, "Sushi") == "frau", "person Sushi attaches to Frau")
        expect(cue_for_mention(homonym, second_at, second_at + 5, "Sushi") == "rohan", "dish Sushi stays distinct from Frau")
        appos = "Sushi, meine Frau war erkältet."
        appos_at = appos.index("Sushi")
        expect(cue_for_mention(appos, appos_at, appos_at + 5, "Sushi") == "frau", "apposition Sushi, meine Frau binds Frau")
        far = "Meine Frau und ich aßen Sushi."
        far_at = far.rindex("Sushi")
        expect(cue_for_mention(far, far_at, far_at + 5, "Sushi") != "frau", "Frau elsewhere in the sentence does not bind the dish")

        sushi_review = sushi.json().get("pending_mask_review") or {}
        sushi_decisions = []
        for item in sushi_review.get("candidates") or []:
            label = item.get("text")
            cue = item.get("cue")
            if label == "Sushi" and cue != "frau":
                sushi_decisions.append({"id": item["id"], "decision": "not_identity"})
            else:
                sushi_decisions.append({"id": item["id"], "decision": "identity"})
        sushi_done = client.post(
            f"/api/journal/conversations/{sushi_conv}/turn/review",
            headers=headers,
            json={"review_id": sushi_review["id"], "decisions": sushi_decisions},
        )
        status_ok(sushi_done, "homonym review")
        expect(get_cue_decision(profile_id, "Sushi", "frau") == "identity", "Frau Sushi is stored as identity")
        expect(get_cue_decision(profile_id, "Sushi", "rohan") == "not_identity", "dish Sushi after Rohan is stored")
        expect(get_cue_decision(profile_id, "Rohan", "sohn") == "identity", "Sohn Rohan cue is stored")
        sushi_again = client.post(
            f"/api/journal/conversations/{sushi_conv}/turn",
            headers=headers,
            json={
                "body": (
                    "Gestern bin ich mit meiner Frau Sushi und meinem Sohn Rohan "
                    "Sushi essen gegangen. Das Restaurant hat mich dabei total beeindruckt."
                )
            },
        )
        status_ok(sushi_again, "repeat homonym sentence")
        expect(not sushi_again.json().get("pending_mask_review"), "same reviewed sentence does not re-ask")

        back = client.put("/api/admin/providers/detect-mode", headers=headers, json={"mode": "semantic"})
        expect(back.json()["detect_operating_mode"] == "semantic", "mode can return to semantic")


if __name__ == "__main__":
    main()