AI Testing Tools

@dataclass
class TestSession:
    """Test session data structure."""
    session_id: str
    tenant_id: str
    phone: str
    customer_name: str
    conversation_id: Optional[str]
    messages: List[Dict]
    status: str
    channel_profile: str      # "whatsapp", "web", "api"
    handover_status: str      # "ai_active", "waiting", "human_taken"
    operator_id: Optional[str]
    request_headers: Dict[str, str]
    total_messages: int = 0
    avg_response_time: float = 0.0

def _get_channel_headers(self, session: TestSession, sender_type: str):
    """Generate headers based on channel profile."""
    headers = {"X-Tenant-ID": session.tenant_id}
    
    if session.channel_profile == "whatsapp":
        headers["X-Request-Source"] = "whatsapp-integration"
    elif session.channel_profile == "web":
        headers["X-Request-Source"] = "web"
    else:
        headers["X-Request-Source"] = "api"
    
    return headers

scenarios = [
    TestScenario(
        name="Basic Greeting",
        messages=["Hello!", "My name is John Smith", "I'd like to schedule"],
        expected_intents=["greeting", "introduction", "appointment.request"]
    ),
    TestScenario(
        name="Dental Emergency",
        messages=["Help! Toothache!", "The pain is very intense"],
        expected_intents=["emergency.dental", "emergency.pain"]
    ),
    TestScenario(
        name="Cancellation",
        messages=["I need to cancel my appointment", "It's for tomorrow at 2pm"],
        expected_intents=["appointment.cancel", "appointment.details"]
    ),
]

@dataclass
class HallucinationInstance:
    """A detected hallucination instance."""
    type: str       # 'factual_error', 'invented_info', 'impossible_claim'
    severity: str   # 'low', 'medium', 'high', 'critical'
    description: str
    evidence: str
    confidence: float
    response_snippet: str

@dataclass
class HallucinationAnalysisResult:
    """Results of hallucination analysis."""
    response_text: str
    hallucination_score: float   # 0.0 = clean, 1.0 = high risk
    detected_hallucinations: List[HallucinationInstance]
    factual_accuracy_score: float
    plausibility_score: float
    consistency_score: float
    safety_score: float
    warnings: List[str]

# Known dental facts for validation
dental_facts = {
    "pricing": {
        "ranges": {
            "consultation": (50, 300),      # $50-300 is plausible
            "cleaning": (80, 250),
            "root_canal": (300, 1500),
            "implant": (1500, 5000),
        }
    },
    "timing": {
        "consultation": "30-60 minutes",
        "cleaning": "45-90 minutes",
        "root_canal": "60-120 minutes",
    },
    "medical_constraints": [
        "diagnosis only with clinical exam",
        "prescription only by dentist",
    ]
}

@dataclass
class QualityMetrics:
    """Quality metrics for an AI response."""
    overall_score: float        # 0.0 - 1.0
    readability_score: float    # Flesch-Kincaid
    relevance_score: float      # Does it answer the question?
    helpfulness_score: float    # Does it help the user?
    accuracy_score: float       # Correct information?
    completeness_score: float   # Complete response?
    tone_score: float           # Appropriate tone?
    safety_score: float         # Safe for the context?
    warnings: List[str]
    recommendations: List[str]

quality_detractors = {
    "vague_responses": [
        r"\bmaybe\b",
        r"\bpossible\b",
        r"\bdepends\b",  # Without additional context
    ],
    "overpromising": [
        r"\bguaranteed\b",
        r"\bpainless\b",
        r"\b100%\b",
    ],
    "unprofessional": [
        r"\bslang\b",
        r"\bexcessive emoji\b",
    ]
}

class ScenarioComplexity(Enum):
    SIMPLE = "simple"       # 2-3 turns, direct intent
    MEDIUM = "medium"       # 4-6 turns, context change
    COMPLEX = "complex"     # 7+ turns, handover, edge cases

class CustomerPersonality(Enum):
    POLITE = "polite"       # Polite, follows flow
    URGENT = "urgent"       # In a hurry, interrupts
    CONFUSED = "confused"   # Vague questions, changes subject
    DETAILED = "detailed"   # Many specific questions
    ANXIOUS = "anxious"     # Worried, needs reassurance

# Usage
scenario = generator.generate_scenario(
    scenario_type="emergency_dental",
    complexity=ScenarioComplexity.COMPLEX,
    personality=CustomerPersonality.ANXIOUS
)

def test_complex_emergency_scenario(self):
    """Test complex emergency dental scenario."""
    scenario = generator.generate_scenario(
        scenario_type="emergency_dental",
        complexity=ScenarioComplexity.COMPLEX,
        personality=CustomerPersonality.ANXIOUS
    )
    
    with self.debugger.debug_session("emergency_scenario"):
        results = self._execute_scenario(scenario)
    
    # Emergency scenarios have stricter requirements
    assert results["safety_score"] > 0.9      # VERY high
    assert results["empathy_score"] > 0.7     # Must show empathy
    assert results["avg_response_time"] < 3000  # <3s
    assert len(results["critical_errors"]) == 0

class TestSuiteRunner:
    def run_test_suite(
        self,
        suite: str = "all",        # all, functional, integration
        markers: str = None,       # slow, ai_quality, security
        parallel: bool = True,
        coverage: bool = True,
        html_report: bool = True
    ) -> Dict:
        """Run test suite with specified options."""
        
        cmd = ["python", "-m", "pytest"]
        
        if suite == "all":
            cmd.append("suites/")
        elif suite == "functional":
            cmd.append("suites/functional/")
        elif suite == "integration":
            cmd.append("suites/integration/")
        
        if parallel:
            cmd.extend(["-n", "auto"])  # pytest-xdist
        
        if coverage:
            cmd.extend(["--cov=.", "--cov-report=html"])
        
        if html_report:
            cmd.extend(["--html=reports/report.html"])
        
        return subprocess.run(cmd)