Add regression and integration tests for therapy and safety services

- Introduced regression tests for therapy service covering remission classification, technique selection weights, crisis keyword detection, homework assignment phases, technique duration filters, session state machine behavior, attribute renaming, SFBT techniques, and trend direction reporting.
- Implemented end-to-end tests for audit chain integrity, ensuring HMAC signing and tamper detection.
- Added tests for PHI at-rest encryption, verifying lifecycle hooks for encrypting and decrypting sensitive data.
- Developed comprehensive tests for the SafetyService, validating the crisis pathway, event emissions, and escalation processes.
- Created unit tests for feature flags, ensuring SSL enforcement is enabled by default in production and staging environments.

Author: Rayyan9477

services/safety_service/tests/test_escalation.py

@@ -3,15 +3,25 @@
 Tests escalation workflows, clinician assignment, and notifications.
 """
 from __future__ import annotations
+
 from dataclasses import dataclass
 from unittest.mock import AsyncMock
-import pytest
 from uuid import UUID, uuid4
+
+import pytest
+
 from services.safety_service.src.domain.escalation import (
-    EscalationManager, EscalationSettings, EscalationResult,
-    EscalationPriority, EscalationStatus, NotificationType,
-    EscalationRecord, NotificationService, ClinicianAssigner,
-    CrisisResourceManager, EscalationWorkflow,
+    ClinicianAssigner,
+    CrisisResourceManager,
+    EscalationManager,
+    EscalationPriority,
+    EscalationRecord,
+    EscalationResult,
+    EscalationSettings,
+    EscalationStatus,
+    EscalationWorkflow,
+    NotificationService,
+    NotificationType,
 )
 
 
@@ -207,6 +217,48 @@ async def test_medium_workflow(self, workflow: EscalationWorkflow) -> None:
         assert "MEDIUM workflow initiated" in result.actions_taken
         assert "Enhanced monitoring enabled" in result.actions_taken
 
+    @pytest.mark.asyncio
+    async def test_medium_workflow_sends_real_supervisor_email(
+        self, workflow: EscalationWorkflow
+    ) -> None:
+        """H-03 regression: MEDIUM workflow must actually send a supervisor
+        email when email notifications are enabled. Previously it logged
+        ``"Event logged for supervisor review"`` as an action but never
+        called the notification service — a false audit claim.
+        """
+        # Replace the notification service with a capturing spy so we can
+        # assert the call actually happens. The spy records every
+        # send_notification invocation.
+        send_calls: list[dict[str, object]] = []
+
+        async def _spy_send(
+            clinician_id, escalation, channel, retry_count=0,
+        ):
+            send_calls.append(
+                {"clinician_id": clinician_id, "channel": channel}
+            )
+            return True
+
+        workflow._notifications.send_notification = _spy_send  # type: ignore[assignment,method-assign]
+
+        escalation = EscalationRecord(
+            user_id=uuid4(),
+            crisis_level="ELEVATED",
+            priority=EscalationPriority.MEDIUM,
+        )
+        result = await workflow.execute_medium_workflow(escalation)
+
+        # If the fix is in place, at least one send_notification call was made
+        assert len(send_calls) >= 1, (
+            "H-03 regression: MEDIUM escalation workflow must call "
+            "notification_service.send_notification() when email is enabled. "
+            "Previously the workflow only logged a misleading action string."
+        )
+        # The recorded action should not claim more than actually happened
+        assert "Event logged for supervisor review" not in result.actions_taken, (
+            "H-03 regression: misleading action string removed"
+        )
+
     @pytest.mark.asyncio
     async def test_low_workflow(self, workflow: EscalationWorkflow) -> None:
         """Test LOW priority workflow execution."""

services/safety_service/tests/test_keyword_detector.py

@@ -1,15 +1,16 @@
 """
 Tests for keyword_detector.py - Fast crisis keyword detection with trie-based matching.
 """
-import pytest
 from decimal import Decimal
 from uuid import uuid4
+
+import pytest
+
 from services.safety_service.src.ml.keyword_detector import (
+    KeywordCategory,
     KeywordDetector,
     KeywordDetectorConfig,
-    KeywordMatch,
     KeywordSeverity,
-    KeywordCategory,
 )
 
 

services/safety_service/tests/test_llm_assessor.py

@@ -1,17 +1,19 @@
 """
 Tests for llm_assessor.py - LLM-based deep risk assessment.
 """
-import pytest
 from decimal import Decimal
 from uuid import uuid4
+
+import pytest
+
 from services.safety_service.src.ml.llm_assessor import (
     LLMAssessor,
     LLMAssessorConfig,
+    ProtectiveFactor,
     RiskAssessment,
-    RiskLevel,
     RiskDimension,
     RiskFactor,
-    ProtectiveFactor,
+    RiskLevel,
 )
 
 
@@ -174,6 +176,79 @@ def test_generate_cache_key(self, assessor: LLMAssessor) -> None:
         assert key1 == key2  # Same input = same key
         assert key1 != key3  # Different input = different key
 
+    def test_cache_key_includes_user_id(self, assessor: LLMAssessor) -> None:
+        """H-05 regression: cache key must differ between users for identical text.
+
+        Before the fix, two users with the same message would collide on the
+        same cache key, and user A could receive user B's risk assessment.
+        This is a privacy + safety bug: a correctly non-crisis assessment
+        for one user could be served for another user whose identical phrase
+        actually indicates crisis given their context.
+        """
+        text = "same utterance across users"
+        context = {"intent": "discuss"}
+
+        user_a = uuid4()
+        user_b = uuid4()
+
+        key_a = assessor._generate_cache_key(text, context, user_a)
+        key_b = assessor._generate_cache_key(text, context, user_b)
+        key_none = assessor._generate_cache_key(text, context)
+        key_a_again = assessor._generate_cache_key(text, context, user_a)
+
+        assert key_a != key_b, (
+            "H-05 regression: identical text for different users must not "
+            "produce the same cache key. This risks cross-user PHI leakage."
+        )
+        assert key_a != key_none, "user-scoped key must differ from anonymous key"
+        assert key_a == key_a_again, "same user + same input must be reproducible"
+
+    @pytest.mark.asyncio
+    async def test_crisis_assessments_are_not_cached(self, assessor: LLMAssessor) -> None:
+        """H-05 regression: HIGH/CRITICAL results must never be cached.
+
+        Caching a transient crisis state could mask a real-time intervention
+        signal on a subsequent call. The assess() method skips caching when
+        the assessment resolves to HIGH or CRITICAL.
+        """
+        # Stub the LLM call to return a HIGH-risk assessment every time.
+        # We return the JSON shape the real parser expects rather than a
+        # RiskAssessment object — that way the full parse path runs.
+        async def _fake_call_llm(system_prompt: str, user_prompt: str) -> str:
+            # Round-trip the assessment through parse_llm_response by returning
+            # a JSON object the real parser understands.
+            return (
+                '{"risk_level":"HIGH","risk_score":0.75,"confidence":0.9,'
+                '"clinical_summary":"simulated high risk",'
+                '"risk_factors":[],"protective_factors":[],"immediate_risk":false,'
+                '"recommended_actions":["monitor"],"warning_signs":[],'
+                '"contextual_notes":""}'
+            )
+
+        assessor._call_llm = _fake_call_llm  # type: ignore[assignment,method-assign]
+
+        user_id = uuid4()
+        text = "I have been thinking about ending it all"
+
+        # Two calls with identical inputs — if caching were active on HIGH,
+        # we'd hit the cache and _call_llm would not run the second time.
+        call_count = {"n": 0}
+        original = _fake_call_llm
+
+        async def _counting_call(sp: str, up: str) -> str:
+            call_count["n"] += 1
+            return await original(sp, up)
+
+        assessor._call_llm = _counting_call  # type: ignore[assignment,method-assign]
+
+        await assessor.assess(text, user_id=user_id)
+        await assessor.assess(text, user_id=user_id)
+
+        assert call_count["n"] == 2, (
+            "H-05 regression: HIGH-risk assessment must not be cached. "
+            "The LLM should be called again on the second identical request."
+        )
+
     def test_get_cached_assessment_miss(self, assessor: LLMAssessor) -> None:
         """Test cache miss returns None."""
         cached = assessor._get_cached_assessment("nonexistent_key")

services/safety_service/tests/test_pattern_matcher.py

@@ -1,13 +1,14 @@
 """
 Tests for pattern_matcher.py - Advanced pattern-based crisis detection.
 """
-import pytest
 from decimal import Decimal
 from uuid import uuid4
+
+import pytest
+
 from services.safety_service.src.ml.pattern_matcher import (
     PatternMatcher,
     PatternMatcherConfig,
-    PatternMatch,
     PatternType,
 )
 

services/safety_service/tests/test_sentiment_analyzer.py

@@ -1,15 +1,15 @@
 """
 Tests for sentiment_analyzer.py - Clinical sentiment analysis for risk assessment.
 """
-import pytest
 from decimal import Decimal
 from uuid import uuid4
+
+import pytest
+
 from services.safety_service.src.ml.sentiment_analyzer import (
+    EmotionalState,
     SentimentAnalyzer,
-    SentimentAnalyzerConfig,
-    SentimentResult,
     SentimentPolarity,
-    EmotionalState,
 )