merge: testing → main (reconcile 2-week divergence)

tests/realism/test_bodies_llm.py

@@ -0,0 +1,128 @@
+"""LLM-enriched body generation with deterministic fallback."""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from decnet.realism.bodies import make_body_with_llm
+from decnet.realism.llm.base import LLMResult, LLMTimeout
+from decnet.realism.llm.circuit import LLMCircuitBreaker
+from decnet.realism.personas import EmailPersona
+from decnet.realism.taxonomy import ContentClass
+
+
+def _persona(uses_llms: bool = False) -> EmailPersona:
+    return EmailPersona(
+        name="admin", email="admin@corp.com", role="ops",
+        tone="direct", mannerisms=["uses bullets"],
+        active_hours="00:00-00:00",
+        uses_llms_heavily=uses_llms,
+    )
+
+
+class _StubLLM:
+    """Async stub: returns canned LLMResult; no subprocess work."""
+
+    def __init__(self, *, text: str = "stub body\n", success: bool = True):
+        self.model = "stub-model"
+        self.timeout = 1.0
+        self._result = LLMResult(
+            success=success, text=text, model=self.model, latency_ms=1,
+        )
+        self.calls = 0
+
+    async def generate(self, prompt: str) -> LLMResult:
+        self.calls += 1
+        return self._result
+
+
+class _TimeoutLLM:
+    model = "timeout-model"
+    timeout = 0.05
+
+    async def generate(self, prompt: str) -> LLMResult:
+        raise LLMTimeout("simulated")
+
+
+@pytest.mark.asyncio
+async def test_no_llm_falls_back_to_template() -> None:
+    body = await make_body_with_llm(ContentClass.NOTE, _persona(), llm=None)
+    assert body.strip()  # template path returns non-empty
+
+
+@pytest.mark.asyncio
+async def test_llm_success_returns_llm_text() -> None:
+    llm = _StubLLM(text="LLM-produced note body\n")
+    body = await make_body_with_llm(
+        ContentClass.NOTE, _persona(), llm=llm,
+    )
+    assert "LLM-produced note body" in body
+    assert llm.calls == 1
+
+
+@pytest.mark.asyncio
+async def test_em_dashes_are_stripped_for_default_persona() -> None:
+    llm = _StubLLM(text="Hi — quick update — see attached.\n")
+    body = await make_body_with_llm(
+        ContentClass.NOTE, _persona(uses_llms=False), llm=llm,
+    )
+    assert "—" not in body
+
+
+@pytest.mark.asyncio
+async def test_em_dashes_pass_through_for_llm_heavy_persona() -> None:
+    llm = _StubLLM(text="Hi — quick update — see attached.\n")
+    body = await make_body_with_llm(
+        ContentClass.NOTE, _persona(uses_llms=True), llm=llm,
+    )
+    assert "—" in body
+
+
+@pytest.mark.asyncio
+async def test_timeout_falls_back_to_template_and_records_failure() -> None:
+    breaker = LLMCircuitBreaker(failure_threshold=3, cooldown_seconds=10.0)
+    body = await make_body_with_llm(
+        ContentClass.NOTE, _persona(),
+        llm=_TimeoutLLM(), breaker=breaker, timeout=0.01,
+    )
+    assert body.strip()  # template fallback returned non-empty
+    assert breaker.state == "closed"  # one failure isn't enough to trip
+
+
+@pytest.mark.asyncio
+async def test_breaker_open_skips_llm_call() -> None:
+    breaker = LLMCircuitBreaker(failure_threshold=1, cooldown_seconds=60.0)
+    breaker.record_failure()  # trip immediately
+    assert breaker.allow_call() is False
+
+    llm = _StubLLM()
+    body = await make_body_with_llm(
+        ContentClass.NOTE, _persona(),
+        llm=llm, breaker=breaker,
+    )
+    # LLM was NOT called (breaker open) — fallback to template.
+    assert llm.calls == 0
+    assert body.strip()
+
+
+@pytest.mark.asyncio
+async def test_system_class_never_invokes_llm() -> None:
+    llm = _StubLLM()
+    body = await make_body_with_llm(
+        ContentClass.LOG_CRON, _persona(), llm=llm,
+    )
+    # System-class content is supposed to look formulaic; LLM-authored
+    # cron logs would be a regression in realism.
+    assert llm.calls == 0
+    assert "CRON[" in body  # template path
+
+
+@pytest.mark.asyncio
+async def test_empty_llm_response_falls_back() -> None:
+    llm = _StubLLM(text="", success=True)
+    body = await make_body_with_llm(
+        ContentClass.NOTE, _persona(), llm=llm,
+    )
+    # LLM ran but produced empty output → template fallback.
+    assert body.strip()