loko/streetup/analytics/tests.py

"""
Tests pour le système Analytics.
"""

from django.test import TestCase, Client, RequestFactory
from django.contrib.auth.models import User
from django.utils import timezone
from datetime import timedelta

from .models import PageView, UserSession
from .middleware import AnalyticsMiddleware


class PageViewModelTest(TestCase):
    """Tests pour le modèle PageView."""

    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )

    def test_create_page_view(self):
        """Test de création d'une vue de page."""
        page_view = PageView.objects.create(
            user=self.user,
            session_key='test_session_123',
            path='/test/page/',
            method='GET',
            ip_address='127.0.0.1',
            response_time_ms=100
        )
        
        self.assertEqual(page_view.user, self.user)
        self.assertEqual(page_view.path, '/test/page/')
        self.assertEqual(page_view.response_time_ms, 100)
        self.assertIsNotNone(page_view.timestamp)

    def test_page_view_str(self):
        """Test de la représentation string d'une PageView."""
        page_view = PageView.objects.create(
            user=self.user,
            session_key='test_session_123',
            path='/test/page/',
        )
        
        str_repr = str(page_view)
        self.assertIn('testuser', str_repr)
        self.assertIn('/test/page/', str_repr)

    def test_page_view_without_user(self):
        """Test de création d'une vue de page sans utilisateur (anonyme)."""
        page_view = PageView.objects.create(
            user=None,
            session_key='anonymous_session',
            path='/public/page/',
        )
        
        self.assertIsNone(page_view.user)
        str_repr = str(page_view)
        self.assertIn('Anonyme', str_repr)


class UserSessionModelTest(TestCase):
    """Tests pour le modèle UserSession."""

    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )

    def test_create_user_session(self):
        """Test de création d'une session utilisateur."""
        now = timezone.now()
        session = UserSession.objects.create(
            user=self.user,
            session_key='test_session_456',
            login_time=now,
            last_activity=now,
            ip_address='127.0.0.1',
            is_active=True
        )
        
        self.assertEqual(session.user, self.user)
        self.assertEqual(session.session_key, 'test_session_456')
        self.assertTrue(session.is_active)
        self.assertIsNone(session.logout_time)

    def test_session_duration(self):
        """Test du calcul de la durée d'une session."""
        now = timezone.now()
        later = now + timedelta(hours=2)
        
        session = UserSession.objects.create(
            user=self.user,
            session_key='test_session_789',
            login_time=now,
            last_activity=later,
            is_active=True
        )
        
        duration = session.duration
        self.assertEqual(duration.total_seconds(), 7200)  # 2 heures
        self.assertEqual(session.duration_seconds, 7200)

    def test_mark_inactive(self):
        """Test de marquage d'une session comme inactive."""
        session = UserSession.objects.create(
            user=self.user,
            session_key='test_session_abc',
            login_time=timezone.now(),
            last_activity=timezone.now(),
            is_active=True
        )
        
        self.assertTrue(session.is_active)
        self.assertIsNone(session.logout_time)
        
        session.mark_inactive()
        session.refresh_from_db()
        
        self.assertFalse(session.is_active)
        self.assertIsNotNone(session.logout_time)

    def test_session_str(self):
        """Test de la représentation string d'une UserSession."""
        session = UserSession.objects.create(
            user=self.user,
            session_key='test_session_def',
            login_time=timezone.now(),
            last_activity=timezone.now(),
            is_active=True
        )
        
        str_repr = str(session)
        self.assertIn('testuser', str_repr)
        self.assertIn('Active', str_repr)


class AnalyticsMiddlewareTest(TestCase):
    """Tests pour le middleware Analytics."""

    def setUp(self):
        self.factory = RequestFactory()
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )
        self.middleware = AnalyticsMiddleware(lambda r: None)

    def test_should_track_normal_request(self):
        """Test que les requêtes normales sont trackées."""
        request = self.factory.get('/test/page/')
        self.assertTrue(self.middleware._should_track(request))

    def test_should_not_track_static_files(self):
        """Test que les fichiers statiques ne sont pas trackés."""
        request = self.factory.get('/static/css/style.css')
        self.assertFalse(self.middleware._should_track(request))

    def test_should_not_track_media_files(self):
        """Test que les fichiers media ne sont pas trackés."""
        request = self.factory.get('/media/images/photo.jpg')
        self.assertFalse(self.middleware._should_track(request))

    def test_should_not_track_favicon(self):
        """Test que le favicon n'est pas tracké."""
        request = self.factory.get('/favicon.ico')
        self.assertFalse(self.middleware._should_track(request))

    def test_should_not_track_head_method(self):
        """Test que les requêtes HEAD ne sont pas trackées."""
        request = self.factory.head('/test/page/')
        self.assertFalse(self.middleware._should_track(request))

    def test_should_track_post_method(self):
        """Test que les requêtes POST sont trackées."""
        request = self.factory.post('/test/form/')
        self.assertTrue(self.middleware._should_track(request))

    def test_get_client_ip(self):
        """Test de récupération de l'adresse IP du client."""
        # IP directe
        request = self.factory.get('/')
        request.META['REMOTE_ADDR'] = '192.168.1.100'
        ip = self.middleware._get_client_ip(request)
        self.assertEqual(ip, '192.168.1.100')

        # IP via proxy (X-Forwarded-For)
        request = self.factory.get('/')
        request.META['HTTP_X_FORWARDED_FOR'] = '203.0.113.1, 192.168.1.1'
        ip = self.middleware._get_client_ip(request)
        self.assertEqual(ip, '203.0.113.1')


class AnalyticsViewsTest(TestCase):
    """Tests pour les vues Analytics."""

    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )
        self.superuser = User.objects.create_superuser(
            username='superuser',
            password='testpass123'
        )

    def test_dashboard_requires_superuser(self):
        """Test que le dashboard nécessite les droits superuser."""
        # Utilisateur non authentifié
        response = self.client.get('/analytics/')
        self.assertEqual(response.status_code, 302)  # Redirection vers login

        # Utilisateur authentifié mais non superuser
        self.client.login(username='testuser', password='testpass123')
        response = self.client.get('/analytics/')
        self.assertEqual(response.status_code, 302)  # Redirection

        # Utilisateur superuser
        self.client.login(username='superuser', password='testpass123')
        response = self.client.get('/analytics/')
        self.assertEqual(response.status_code, 200)  # Accès autorisé

    def test_dashboard_displays_stats(self):
        """Test que le dashboard affiche les statistiques."""
        # Créer quelques données de test
        PageView.objects.create(
            user=self.user,
            session_key='session1',
            path='/test/',
        )
        
        self.client.login(username='superuser', password='testpass123')
        response = self.client.get('/analytics/')
        
        self.assertEqual(response.status_code, 200)
        self.assertIn('stats', response.context)
        self.assertIn('chart_data', response.context)

    def test_dashboard_days_filter(self):
        """Test du filtre de période du dashboard."""
        self.client.login(username='superuser', password='testpass123')
        
        # 7 jours
        response = self.client.get('/analytics/?days=7')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['days'], 7)
        
        # 30 jours
        response = self.client.get('/analytics/?days=30')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['days'], 30)


class AnalyticsIntegrationTest(TestCase):
    """Tests d'intégration du système Analytics."""

    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )

    def test_page_view_tracking_flow(self):
        """Test du flux complet de tracking d'une page view."""
        # Se connecter
        client = Client()
        client.login(username='testuser', password='testpass123')
        
        # Naviguer sur une page (le middleware devrait créer une PageView)
        # Note: En environnement de test, le middleware peut ne pas être actif
        # Ce test vérifie plutôt la structure
        
        # Vérifier qu'on peut créer manuellement une PageView
        initial_count = PageView.objects.count()
        PageView.objects.create(
            user=self.user,
            session_key=client.session.session_key or 'test_session',
            path='/test/page/',
        )
        
        final_count = PageView.objects.count()
        self.assertEqual(final_count, initial_count + 1)