django-cfg 1.1.61__py3-none-any.whl → 1.1.63__py3-none-any.whl

django_cfg/apps/newsletter/tests/test_email_tracking.py

@@ -1,332 +0,0 @@
-"""
-Tests for email tracking functionality.
-"""
-
-import uuid
-from django.test import TestCase, Client
-from django.contrib.auth import get_user_model
-from django.urls import reverse
-from django.utils import timezone
-from unittest.mock import patch, MagicMock
-
-from ..models import Newsletter, EmailLog, NewsletterSubscription, NewsletterCampaign
-from ..services.email_service import NewsletterEmailService
-
-User = get_user_model()
-
-
-class EmailTrackingTestCase(TestCase):
-    """Test cases for email tracking functionality"""
-    
-    def setUp(self):
-        """Set up test data"""
-        self.client = Client()
-        
-        # Create test user
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123',
-            is_active=True
-        )
-        
-        # Create test newsletter
-        self.newsletter = Newsletter.objects.create(
-            title='Test Newsletter',
-            description='Test newsletter content',
-            is_active=True
-        )
-        
-        # Create email log
-        self.email_log = EmailLog.objects.create(
-            user=self.user,
-            newsletter=self.newsletter,
-            recipient='test@example.com',
-            subject='Test Subject',
-            body='<p>Test body</p>',
-            status=EmailLog.EmailLogStatus.SENT
-        )
-    
-    def test_email_log_tracking_fields(self):
-        """Test that email log has tracking fields"""
-        self.assertIsNone(self.email_log.opened_at)
-        self.assertIsNone(self.email_log.clicked_at)
-        self.assertFalse(self.email_log.is_opened)
-        self.assertFalse(self.email_log.is_clicked)
-    
-    def test_mark_opened(self):
-        """Test marking email as opened"""
-        # Initially not opened
-        self.assertFalse(self.email_log.is_opened)
-        self.assertIsNone(self.email_log.opened_at)
-        
-        # Mark as opened
-        self.email_log.mark_opened()
-        
-        # Check that it's marked as opened
-        self.assertTrue(self.email_log.is_opened)
-        self.assertIsNotNone(self.email_log.opened_at)
-        
-        # Mark as opened again - should not change timestamp
-        original_opened_at = self.email_log.opened_at
-        self.email_log.mark_opened()
-        self.assertEqual(self.email_log.opened_at, original_opened_at)
-    
-    def test_mark_clicked(self):
-        """Test marking email link as clicked"""
-        # Initially not clicked
-        self.assertFalse(self.email_log.is_clicked)
-        self.assertIsNone(self.email_log.clicked_at)
-        
-        # Mark as clicked
-        self.email_log.mark_clicked()
-        
-        # Check that it's marked as clicked
-        self.assertTrue(self.email_log.is_clicked)
-        self.assertIsNotNone(self.email_log.clicked_at)
-        
-        # Mark as clicked again - should not change timestamp
-        original_clicked_at = self.email_log.clicked_at
-        self.email_log.mark_clicked()
-        self.assertEqual(self.email_log.clicked_at, original_clicked_at)
-    
-    def test_track_email_open_view(self):
-        """Test email open tracking view"""
-        # Get tracking URL
-        url = reverse('cfg_newsletter:track-open', kwargs={'email_log_id': self.email_log.id})
-        
-        # Make request to tracking pixel
-        response = self.client.get(url)
-        
-        # Check response
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response['Content-Type'], 'image/gif')
-        
-        # Check that email log was marked as opened
-        self.email_log.refresh_from_db()
-        self.assertTrue(self.email_log.is_opened)
-        self.assertIsNotNone(self.email_log.opened_at)
-    
-    def test_track_email_open_invalid_id(self):
-        """Test email open tracking with invalid ID"""
-        # Use random UUID
-        invalid_id = uuid.uuid4()
-        url = reverse('cfg_newsletter:track-open', kwargs={'email_log_id': invalid_id})
-        
-        # Make request - should still return pixel but not crash
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response['Content-Type'], 'image/gif')
-    
-    def test_track_email_click_view(self):
-        """Test email click tracking view"""
-        # Get tracking URL with redirect
-        redirect_url = 'https://example.com/target'
-        url = reverse('cfg_newsletter:track-click', kwargs={'email_log_id': self.email_log.id})
-        url += f'?url={redirect_url}'
-        
-        # Make request to tracking URL
-        response = self.client.get(url)
-        
-        # Check redirect response
-        self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, redirect_url)
-        
-        # Check that email log was marked as clicked
-        self.email_log.refresh_from_db()
-        self.assertTrue(self.email_log.is_clicked)
-        self.assertIsNotNone(self.email_log.clicked_at)
-    
-    def test_track_email_click_no_url(self):
-        """Test email click tracking without redirect URL"""
-        # Get tracking URL without redirect
-        url = reverse('cfg_newsletter:track-click', kwargs={'email_log_id': self.email_log.id})
-        
-        # Make request to tracking URL
-        response = self.client.get(url)
-        
-        # Check redirect to default URL
-        self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, '/')
-        
-        # Check that email log was marked as clicked
-        self.email_log.refresh_from_db()
-        self.assertTrue(self.email_log.is_clicked)
-    
-    def test_track_email_click_invalid_id(self):
-        """Test email click tracking with invalid ID"""
-        # Use random UUID
-        invalid_id = uuid.uuid4()
-        redirect_url = 'https://example.com/target'
-        url = reverse('cfg_newsletter:track-click', kwargs={'email_log_id': invalid_id})
-        url += f'?url={redirect_url}'
-        
-        # Make request - should still redirect but not crash
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, redirect_url)
-
-
-class EmailServiceTrackingTestCase(TestCase):
-    """Test cases for email service tracking integration"""
-    
-    def setUp(self):
-        """Set up test data"""
-        # Create test user
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123',
-            is_active=True
-        )
-        
-        # Create newsletter subscription
-        self.newsletter = Newsletter.objects.create(
-            title='Test Newsletter Service',
-            description='Test newsletter content',
-            is_active=True
-        )
-        
-        NewsletterSubscription.objects.create(
-            user=self.user,
-            newsletter=self.newsletter,
-            email=self.user.email,
-            is_active=True
-        )
-        
-        self.email_service = NewsletterEmailService()
-    
-    @patch('django_cfg.modules.django_email.DjangoEmailService.send_template_with_tracking')
-    def test_send_bulk_email_with_tracking(self, mock_send_tracking):
-        """Test sending bulk email with tracking enabled"""
-        # Mock successful sending
-        mock_send_tracking.return_value = 1
-        
-        # Send bulk email with tracking
-        result = self.email_service.send_bulk_email(
-            recipients=['test@example.com'],
-            subject='Test Subject',
-            email_title='Test Title',
-            main_text='Test content',
-            enable_tracking=True,
-            newsletter=self.newsletter
-        )
-        
-        # Check result
-        self.assertEqual(result['sent_count'], 1)
-        self.assertEqual(result['failed_count'], 0)
-        
-        # Check that email log was created
-        email_logs = EmailLog.objects.filter(newsletter=self.newsletter)
-        self.assertEqual(email_logs.count(), 1)
-        
-        email_log = email_logs.first()
-        self.assertEqual(email_log.status, EmailLog.EmailLogStatus.SENT)
-        self.assertIsNotNone(email_log.sent_at)
-        
-        # Check that tracking method was called
-        mock_send_tracking.assert_called_once()
-        call_args = mock_send_tracking.call_args
-        self.assertIn('email_log_id', call_args.kwargs)
-        self.assertEqual(call_args.kwargs['email_log_id'], str(email_log.id))
-    
-    @patch('django_cfg.modules.django_email.DjangoEmailService.send_template')
-    def test_send_bulk_email_without_tracking(self, mock_send):
-        """Test sending bulk email without tracking"""
-        # Mock successful sending
-        mock_send.return_value = 1
-        
-        # Send bulk email without tracking
-        result = self.email_service.send_bulk_email(
-            recipients=['test@example.com'],
-            subject='Test Subject',
-            email_title='Test Title',
-            main_text='Test content',
-            enable_tracking=False,
-            newsletter=self.newsletter
-        )
-        
-        # Check result
-        self.assertEqual(result['sent_count'], 1)
-        self.assertEqual(result['failed_count'], 0)
-        
-        # Check that regular send method was called (not tracking)
-        mock_send.assert_called_once()
-        
-        # Email log should NOT be created when tracking is disabled
-        email_logs = EmailLog.objects.filter(newsletter=self.newsletter)
-        self.assertEqual(email_logs.count(), 0)  # No logs when tracking disabled
-    
-    def test_send_newsletter_email_with_tracking(self):
-        """Test sending newsletter email with tracking enabled"""
-        # Send newsletter email (no mocking - test real functionality)
-        result = self.email_service.send_newsletter_email(
-            newsletter=self.newsletter,
-            subject='Test Newsletter',
-            email_title='Newsletter Title',
-            main_text='Newsletter content',
-            send_to_all=True  # Send to all subscribers
-        )
-        
-        # Check result
-        self.assertEqual(result['sent_count'], 1)
-        self.assertEqual(result['failed_count'], 0)
-        
-        # Check that email log was created with tracking
-        email_logs = EmailLog.objects.filter(newsletter=self.newsletter)
-        self.assertEqual(email_logs.count(), 1)
-        
-        email_log = email_logs.first()
-        self.assertEqual(email_log.status, EmailLog.EmailLogStatus.SENT)
-
-
-class EmailTemplateTrackingTestCase(TestCase):
-    """Test cases for email template tracking integration"""
-    
-    def setUp(self):
-        """Set up test data"""
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123',
-            is_active=True
-        )
-        
-        self.newsletter = Newsletter.objects.create(
-            title='Test Newsletter',
-            description='Test newsletter content',
-            is_active=True
-        )
-        
-        self.email_log = EmailLog.objects.create(
-            user=self.user,
-            newsletter=self.newsletter,
-            recipient='test@example.com',
-            subject='Test Subject',
-            body='<p>Test body</p>',
-            status=EmailLog.EmailLogStatus.SENT
-        )
-    
-    @patch('django_cfg.modules.django_email.DjangoEmailService._prepare_template_context')
-    def test_template_context_with_tracking(self, mock_prepare_context):
-        """Test that template context includes tracking URLs"""
-        from django_cfg.modules.django_email import DjangoEmailService
-        
-        # Mock context preparation
-        mock_prepare_context.return_value = {
-            'email_title': 'Test Title',
-            'tracking_pixel_url': f'http://example.com/api/newsletter/track/open/{self.email_log.id}/',
-            'tracking_click_url': f'http://example.com/api/newsletter/track/click/{self.email_log.id}'
-        }
-        
-        service = DjangoEmailService()
-        context = service._prepare_template_context(
-            {'email_title': 'Test Title'}, 
-            email_log_id=str(self.email_log.id)
-        )
-        
-        # Check that tracking URLs are included
-        self.assertIn('tracking_pixel_url', context)
-        self.assertIn('tracking_click_url', context)
-        self.assertIn(str(self.email_log.id), context['tracking_pixel_url'])
-        self.assertIn(str(self.email_log.id), context['tracking_click_url'])

django_cfg/apps/newsletter/tests/test_newsletter_manager.py

@@ -1,83 +0,0 @@
-import threading
-import time
-from unittest.mock import patch, MagicMock
-from django.test import TestCase, override_settings
-from django.contrib.auth import get_user_model
-from django.utils import timezone
-
-from ..models import Newsletter, EmailLog
-# NewsletterManager is no longer used - tests updated to reflect current architecture
-
-User = get_user_model()
-
-
-class NewsletterManagerTestCase(TestCase):
-    """Test cases for Newsletter model functionality"""
-    
-    def setUp(self):
-        """Set up test data"""
-        
-        # Create test user
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123',
-            is_active=True,
-        )
-        
-        # Create test newsletter
-        self.newsletter = Newsletter.objects.create(
-            title='Test Newsletter',
-            description='Test newsletter content',
-            is_active=True
-        )
-    
-    def test_newsletter_creation(self):
-        """Test newsletter creation"""
-        self.assertEqual(self.newsletter.title, 'Test Newsletter')
-        self.assertEqual(self.newsletter.description, 'Test newsletter content')
-        self.assertTrue(self.newsletter.is_active)
-    
-    def test_newsletter_filtering(self):
-        """Test newsletter filtering by active status"""
-        # Create inactive newsletter
-        inactive_newsletter = Newsletter.objects.create(
-            title='Inactive Newsletter',
-            description='Inactive content',
-            is_active=False
-        )
-        
-        active_newsletters = Newsletter.objects.filter(is_active=True)
-        self.assertEqual(active_newsletters.count(), 1)
-        self.assertEqual(active_newsletters.first(), self.newsletter)
-    
-    def test_newsletter_str_representation(self):
-        """Test newsletter string representation"""
-        # Newsletter model __str__ method returns just the title
-        self.assertEqual(str(self.newsletter), self.newsletter.title)
-    
-    def test_newsletter_ordering(self):
-        """Test newsletter ordering by creation date"""
-        # Create another newsletter
-        newer_newsletter = Newsletter.objects.create(
-            title='Newer Newsletter',
-            description='Newer content',
-            is_active=True
-        )
-        
-        newsletters = list(Newsletter.objects.all())
-        # Should be ordered by created_at descending
-        self.assertEqual(newsletters[0], newer_newsletter)
-        self.assertEqual(newsletters[1], self.newsletter)
-    
-    def test_newsletter_meta_options(self):
-        """Test newsletter model meta options"""
-        meta = Newsletter._meta
-        
-        self.assertEqual(meta.verbose_name, 'Newsletter')
-        self.assertEqual(meta.verbose_name_plural, 'Newsletters')
-        self.assertEqual(meta.ordering, ['-created_at'])
-    
-    
-    
-    

django_cfg/apps/newsletter/tests/test_newsletter_models.py

@@ -1,157 +0,0 @@
-from django.test import TestCase
-from django.contrib.auth import get_user_model
-from django.utils import timezone
-from unittest.mock import patch
-
-from ..models import Newsletter, EmailLog
-# NewsletterManager is no longer used
-
-User = get_user_model()
-
-
-class NewsletterModelTestCase(TestCase):
-    """Test cases for Newsletter model with custom manager"""
-    
-    def setUp(self):
-        """Set up test data"""
-        # Create test user
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123',
-            is_active=True
-        )
-        
-        # Create test newsletters
-        self.active_newsletter = Newsletter.objects.create(
-            title='Active Newsletter',
-            description='Active content',
-            is_active=True
-        )
-        
-        self.inactive_newsletter = Newsletter.objects.create(
-            title='Inactive Newsletter',
-            description='Inactive content',
-            is_active=False
-        )
-    
-    def test_newsletter_str_representation(self):
-        """Test string representation of newsletter"""
-        # Newsletter model __str__ method returns just the title
-        self.assertEqual(
-            str(self.active_newsletter),
-            self.active_newsletter.title
-        )
-    
-    def test_newsletter_default_active_status(self):
-        """Test that new newsletter is active by default"""
-        newsletter = Newsletter.objects.create(
-            title='New Newsletter',
-            description='New content'
-        )
-        self.assertTrue(newsletter.is_active)
-    
-    def test_newsletter_active_field(self):
-        """Test newsletter active field"""
-        self.assertTrue(self.active_newsletter.is_active)
-        self.assertFalse(self.inactive_newsletter.is_active)
-    
-    def test_newsletter_ordering(self):
-        """Test that newsletters are ordered by created_at descending"""
-        newsletters = list(Newsletter.objects.all())
-        
-        # Check that newsletters are ordered by created_at descending
-        for i in range(len(newsletters) - 1):
-            self.assertGreaterEqual(
-                newsletters[i].created_at,
-                newsletters[i + 1].created_at
-            )
-    
-    def test_newsletter_creation_fields(self):
-        """Test newsletter creation with required fields"""
-        newsletter = Newsletter.objects.create(
-            title='Test Newsletter',
-            description='Test content'
-        )
-        self.assertEqual(newsletter.title, 'Test Newsletter')
-        self.assertEqual(newsletter.description, 'Test content')
-        self.assertTrue(newsletter.is_active)  # Default value
-    
-    def test_newsletter_filtering(self):
-        """Test newsletter filtering by active status"""
-        active_newsletters = Newsletter.objects.filter(is_active=True)
-        inactive_newsletters = Newsletter.objects.filter(is_active=False)
-        
-        self.assertEqual(active_newsletters.count(), 1)
-        self.assertEqual(inactive_newsletters.count(), 1)
-        self.assertIn(self.active_newsletter, active_newsletters)
-        self.assertIn(self.inactive_newsletter, inactive_newsletters)
-    
-    def test_newsletter_meta_options(self):
-        """Test newsletter model meta options"""
-        meta = Newsletter._meta
-        
-        self.assertEqual(meta.verbose_name, 'Newsletter')
-        self.assertEqual(meta.verbose_name_plural, 'Newsletters')
-        self.assertEqual(meta.ordering, ['-created_at'])
-
-
-class NewsletterEmailLogRelationshipTestCase(TestCase):
-    """Test relationship between Newsletter and EmailLog"""
-    
-    def setUp(self):
-        """Set up test data"""
-        # Create test users
-        self.user1 = User.objects.create_user(
-            username='user1',
-            email='user1@example.com',
-            password='testpass123',
-            is_active=True
-        )
-        
-        self.user2 = User.objects.create_user(
-            username='user2',
-            email='user2@example.com',
-            password='testpass123',
-            is_active=True
-        )
-        
-        # Create test newsletter
-        self.newsletter = Newsletter.objects.create(
-            title='Test Newsletter',
-            description='Test newsletter content',
-            is_active=True
-        )
-    
-    def test_newsletter_email_logs_relationship(self):
-        """Test relationship between Newsletter and EmailLog"""
-        # Create email logs for the newsletter
-        EmailLog.objects.create(
-            user=self.user1,
-            newsletter=self.newsletter,
-            recipient='user1@example.com',
-            subject='Test Subject',
-            body='<p>Test body</p>',
-            status=EmailLog.EmailLogStatus.SENT
-        )
-        
-        EmailLog.objects.create(
-            user=self.user2,
-            newsletter=self.newsletter,
-            recipient='user2@example.com',
-            subject='Test Subject',
-            body='<p>Test body</p>',
-            status=EmailLog.EmailLogStatus.SENT
-        )
-        
-        # Check that newsletter has email logs
-        self.assertEqual(self.newsletter.email_logs.count(), 2)
-        
-        # Check that we can access email logs through newsletter
-        email_logs = list(self.newsletter.email_logs.all())
-        self.assertEqual(len(email_logs), 2)
-        
-        # Check email log details (order may vary)
-        users_in_logs = {log.user for log in email_logs}
-        self.assertIn(self.user1, users_in_logs)
-        self.assertIn(self.user2, users_in_logs) 

django_cfg/apps/support/tests/test_models.py

@@ -1,106 +0,0 @@
-from django.test import TestCase, override_settings
-from django.contrib.auth import get_user_model
-from unittest.mock import patch
-from ..models import Ticket, Message
-
-User = get_user_model()
-
-class TicketModelTest(TestCase):
-    def setUp(self):
-        self.user = get_user_model().objects.create(username='testuser', email='user@example.com')
-
-    def test_create_ticket_default_status(self):
-        ticket = Ticket.objects.create(user=self.user, subject='Test subject')
-        self.assertEqual(Ticket.TicketStatus, Ticket.TicketStatus.OPEN)
-        self.assertEqual(str(ticket), f"Ticket #{ticket.pk} - {self.user.username} (Open)")
-        self.assertTrue(ticket.uuid)
-
-    def test_ticket_status_choices(self):
-        ticket = Ticket.objects.create(user=self.user, subject='Test', status=Ticket.TicketStatus.RESOLVED)
-        self.assertEqual(Ticket.TicketStatus, Ticket.TicketStatus.RESOLVED)
-        self.assertEqual(ticket.get_status_display(), 'Resolved')
-
-    def test_ticket_ordering(self):
-        """Test that tickets are ordered by created_at descending."""
-        ticket1 = Ticket.objects.create(user=self.user, subject='First ticket')
-        ticket2 = Ticket.objects.create(user=self.user, subject='Second ticket')
-        
-        # Get tickets in default ordering
-        tickets = list(Ticket.objects.all())
-        
-        # Should be ordered by created_at descending (newest first)
-        self.assertEqual(tickets[0], ticket2)
-        self.assertEqual(tickets[1], ticket1)
-
-
-class UserModelTest(TestCase):
-    def test_display_username_with_username(self):
-        """Test display_username property with username."""
-        user = User.objects.create(
-            username='test_user_123',
-            email='test@example.com'
-        )
-        self.assertEqual(user.display_username, 'Test User 123')
-
-    def test_display_username_with_special_chars(self):
-        """Test display_username property with special characters."""
-        user = User.objects.create(
-            username='test-user.123',
-            email='test@example.com'
-        )
-        self.assertEqual(user.display_username, 'Test User 123')
-
-    def test_display_username_fallback_to_name(self):
-        """Test display_username property falls back to full name."""
-        user = User.objects.create(
-            username='',
-            email='test@example.com',
-            first_name='John',
-            last_name='Doe'
-        )
-        self.assertEqual(user.display_username, 'John Doe')
-
-    def test_display_username_fallback_to_email(self):
-        """Test display_username property falls back to email."""
-        user = User.objects.create(
-            username='',
-            email='john.doe@example.com'
-        )
-        self.assertEqual(user.display_username, 'John.doe')
-
-
-class MessageModelTest(TestCase):
-    def setUp(self):
-        self.user = get_user_model().objects.create(username='testuser', email='user@example.com')
-        self.admin = get_user_model().objects.create(username='admin', is_staff=True, email='admin@example.com')
-        self.ticket = Ticket.objects.create(user=self.user, subject='Test subject')
-
-    def test_create_message_user(self):
-        msg = Message.objects.create(ticket=self.ticket, sender=self.user, text='Hello')
-        self.assertEqual(msg.ticket, self.ticket)
-        self.assertEqual(msg.sender, self.user)
-        self.assertFalse(msg.sender.is_staff)
-        self.assertEqual(msg.text, 'Hello')
-        self.assertTrue(msg.uuid)
-
-    def test_create_message_admin(self):
-        msg = Message.objects.create(ticket=self.ticket, sender=self.admin, text='Admin reply')
-        self.assertEqual(msg.ticket, self.ticket)
-        self.assertEqual(msg.sender, self.admin)
-        self.assertTrue(msg.sender.is_staff)
-        self.assertEqual(msg.text, 'Admin reply')
-        self.assertTrue(msg.uuid)
-
-    def test_message_ordering(self):
-        Message.objects.create(ticket=self.ticket, sender=self.user, text='First')
-        Message.objects.create(ticket=self.ticket, sender=self.user, text='Second')
-        messages = list(self.ticket.messages.all())
-        self.assertEqual(messages[0].text, 'First')
-        self.assertEqual(messages[1].text, 'Second')
-
-    @override_settings(EMAIL_BACKEND='django.core.mail.backends.locmem.EmailBackend')
-    @patch('django.core.mail.EmailMultiAlternatives.send')
-    def test_send_support_reply_email(self, mock_send):
-        msg = Message.objects.create(ticket=self.ticket, sender=self.admin, text='Admin reply')
-        Message.objects.send_support_reply_email(msg)
-        self.assertTrue(mock_send.called)