apps/intelligence/tests.py

"""
Tests for Intelligence App — Phase 6.
"""
from django.test import TestCase
from django.contrib.auth import get_user_model

from apps.accounts.services import register_user
from apps.organizations.services import create_org
from apps.intelligence.models import EventLog, ChatSession
from apps.intelligence.services import log_event, get_events
from django.urls import reverse

User = get_user_model()


class EventLoggingTests(TestCase):
    def test_log_event_direct(self):
        """Test direct usage of log_event service."""
        user = User.objects.create_user("test@example.com", "password")
        log_event(
            event_type="manual_test",
            actor=user,
            metadata={"foo": "bar"}
        )
        
        log = EventLog.objects.last()
        self.assertEqual(log.event_type, "manual_test")
        self.assertEqual(log.actor_user, user)
        self.assertEqual(log.metadata["foo"], "bar")

    def test_user_registration_logging(self):
        """Test that registering a user creates a user_registered event."""
        email = "logger@example.com"
        register_user(email, "StrongPass123!Safe", org_name="Test Org", business_type="SaaS")
        
        log = EventLog.objects.get(event_type="user_registered")
        self.assertEqual(log.actor_user.email, email)
        self.assertEqual(log.metadata["email_domain"], "example.com")

    def test_org_creation_logging(self):
        """Test that creating an org creates an org_created event."""
        user = register_user("owner@example.com", "StrongPass123!", org_name="Test Org", business_type="SaaS")
        org = create_org("Logging Corp", user)
        
        log = EventLog.objects.get(event_type="org_created")
        self.assertEqual(log.org, org)
        self.assertEqual(log.actor_user, user)
        self.assertEqual(log.metadata["name"], "Logging Corp")


    def test_get_events_filter(self):
        """Test filtering events."""
        user = register_user("filter@example.com", "Pass123!", org_name="Test Org", business_type="SaaS")
        
        log_event("type_a", actor=user)
        log_event("type_b", actor=user)
        
        events_a = get_events(event_type="type_a")
        self.assertEqual(events_a.count(), 1)
        self.assertEqual(events_a.first().event_type, "type_a")


class AIServiceTests(TestCase):
    def test_chat_flow(self):
        """Test creating a session and exchanging messages."""
        user = register_user("ai_user@example.com", "StrongPass123!", org_name="Test Org", business_type="SaaS")
        
        # 1. Create Session
        from apps.intelligence.services import create_session, generate_response
        session = create_session(user, title="Test Chat", system_prompt="You are a bot.")
        self.assertEqual(session.title, "Test Chat")
        
        # 2. Send Message
        response_msg = generate_response(session.pk, "Hello AI")
        
        # 3. Verify interaction
        self.assertEqual(response_msg.role, "assistant")
        self.assertIn("Mock AI Response to: Hello AI", response_msg.content)
        self.assertEqual(session.messages.count(), 2)  # User + AI


class IntelligenceViewTests(TestCase):
    def setUp(self):
        from apps.audit.services import record_consent
        self.user = register_user("view_ai@example.com", "StrongPass123!", org_name="Test Org", business_type="SaaS")
        record_consent(self.user, "1.0")
        self.client.force_login(self.user)
        
    def test_event_log_view(self):
        """Test event log page."""
        log_event("test_view", actor=self.user)
        response = self.client.get(reverse("intelligence:event-log"))
        
        self.assertEqual(response.status_code, 200)
        # Jinja2 templates are not tracked by assertTemplateUsed,
        # so we verify rendered content instead.
        self.assertContains(response, "test_view")

    def test_chat_views(self):
        """Test chat flow views."""
        # 1. Start Chat — creates session and redirects
        start_url = reverse("intelligence:chat-start")
        response = self.client.get(start_url)
        self.assertEqual(response.status_code, 302)  # Redirect to detail
        
        session = ChatSession.objects.filter(user=self.user).last()
        self.assertIsNotNone(session, "start_chat_view should create a ChatSession")
        detail_url = reverse("intelligence:chat-detail", args=[session.id])
        
        # 2. View Detail
        response = self.client.get(detail_url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "New Chat")
        
        # 3. Send Message (HTMX)
        msg_url = reverse("intelligence:chat-message-create", args=[session.id])
        response = self.client.post(msg_url, {"content": "Hello View"})
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Hello View")       # User msg
        self.assertContains(response, "Mock AI Response")  # AI msg