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

django_cfg/apps/accounts/tests/test_views.py

@@ -1,255 +0,0 @@
-from django.urls import reverse
-from django.contrib.auth import get_user_model
-from rest_framework.test import APITestCase
-from rest_framework import status
-from rest_framework_simplejwt.tokens import RefreshToken
-from unittest.mock import patch
-
-from ..models import OTPSecret
-
-User = get_user_model()
-
-
-class OTPViewsTest(APITestCase):
-    """Test OTP authentication views."""
-    
-    def setUp(self):
-        self.email = "test@example.com"
-        self.source_url = "https://reforms.ai"
-        self.otp_request_url = reverse("otp-request-otp")
-        self.otp_verify_url = reverse("otp-verify-otp")
-
-    @patch("apps.accounts.services.otp_service.OTPService.request_otp")
-    def test_otp_request_success(self, mock_request_otp):
-        """Test successful OTP request."""
-        mock_request_otp.return_value = (True, "success")
-
-        data = {"email": self.email}
-        response = self.client.post(self.otp_request_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("message", response.data)
-        mock_request_otp.assert_called_once_with(self.email, None)
-
-    @patch("apps.accounts.services.otp_service.OTPService.request_otp")
-    def test_otp_request_with_source_url(self, mock_request_otp):
-        """Test successful OTP request with source_url."""
-        mock_request_otp.return_value = (True, "success")
-
-        data = {"email": self.email, "source_url": self.source_url}
-        response = self.client.post(self.otp_request_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("message", response.data)
-        mock_request_otp.assert_called_once_with(self.email, self.source_url)
-
-    @patch("apps.accounts.services.otp_service.OTPService.request_otp")
-    def test_otp_request_failure(self, mock_request_otp):
-        """Test OTP request failure."""
-        mock_request_otp.return_value = (False, "email_send_failed")
-
-        data = {"email": self.email}
-        response = self.client.post(self.otp_request_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
-        self.assertIn("error", response.data)
-
-    def test_otp_request_invalid_email(self):
-        """Test OTP request with invalid email."""
-        data = {"email": "invalid-email"}
-        response = self.client.post(self.otp_request_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-    def test_otp_request_missing_email(self):
-        """Test OTP request without email."""
-        response = self.client.post(self.otp_request_url, {})
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-    def test_otp_request_invalid_source_url(self):
-        """Test OTP request with invalid source_url."""
-        data = {"email": self.email, "source_url": "not-a-url"}
-        response = self.client.post(self.otp_request_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-    @patch("apps.accounts.services.otp_service.OTPService.verify_otp")
-    def test_otp_verify_success(self, mock_verify_otp):
-        """Test successful OTP verification."""
-        user = User.objects.create_user(email=self.email, username="testuser")
-        mock_verify_otp.return_value = user
-
-        data = {"email": self.email, "otp": "123456"}
-        response = self.client.post(self.otp_verify_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("access", response.data)
-        self.assertIn("refresh", response.data)
-        self.assertIn("user", response.data)
-        self.assertEqual(response.data["user"]["email"], self.email)
-
-    @patch("apps.accounts.services.otp_service.OTPService.verify_otp")
-    def test_otp_verify_with_source_url(self, mock_verify_otp):
-        """Test successful OTP verification with source_url."""
-        user = User.objects.create_user(email=self.email, username="testuser")
-        mock_verify_otp.return_value = user
-
-        data = {"email": self.email, "otp": "123456", "source_url": self.source_url}
-        response = self.client.post(self.otp_verify_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("access", response.data)
-        self.assertIn("refresh", response.data)
-        self.assertIn("user", response.data)
-        mock_verify_otp.assert_called_once_with(self.email, "123456", self.source_url)
-
-    @patch("apps.accounts.services.otp_service.OTPService.verify_otp")
-    def test_otp_verify_failure(self, mock_verify_otp):
-        """Test OTP verification failure."""
-        mock_verify_otp.return_value = None
-
-        data = {"email": self.email, "otp": "123456"}
-        response = self.client.post(self.otp_verify_url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_410_GONE)
-        self.assertIn("error", response.data)
-
-    def test_otp_verify_invalid_data(self):
-        """Test OTP verification with invalid data."""
-        # Invalid OTP length
-        data = {"email": self.email, "otp": "12345"}  # Too short
-        response = self.client.post(self.otp_verify_url, data)
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-        # Invalid OTP characters
-        data = {"email": self.email, "otp": "12345a"}  # Contains letter
-        response = self.client.post(self.otp_verify_url, data)
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-        # Missing required fields
-        data = {"source_url": self.source_url}
-        response = self.client.post(self.otp_verify_url, data)
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-
-class UserViewsTest(APITestCase):
-    """Test user profile views."""
-    
-    def setUp(self):
-        self.user = User.objects.create_user(
-            email="test@example.com", username="testuser", password="testpass123"
-        )
-        self.client.force_authenticate(user=self.user)
-
-    def test_user_detail_authenticated(self):
-        """Test getting user detail when authenticated."""
-        url = reverse("profile_detail")
-        response = self.client.get(url)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data["email"], self.user.email)
-        # username field removed from serializer
-
-    def test_user_detail_unauthenticated(self):
-        """Test getting user detail when not authenticated."""
-        self.client.force_authenticate(user=None)
-        url = reverse("profile_detail")
-        response = self.client.get(url)
-
-        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
-
-
-class TokenRefreshViewTest(APITestCase):
-    """Test token refresh view."""
-    
-    
-
-    def setUp(self):
-        self.user = User.objects.create_user(
-            email="test@example.com", username="testuser"
-        )
-        self.refresh = RefreshToken.for_user(self.user)
-
-    def test_token_refresh_success(self):
-        """Test successful token refresh."""
-        url = reverse("token_refresh")
-        data = {"refresh": str(self.refresh)}
-        response = self.client.post(url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("access", response.data)
-
-    def test_token_refresh_invalid_token(self):
-        """Test token refresh with invalid token."""
-        url = reverse("token_refresh")
-        data = {"refresh": "invalid-token"}
-        response = self.client.post(url, data)
-
-        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
-
-    def test_token_refresh_missing_token(self):
-        """Test token refresh without token."""
-        url = reverse("token_refresh")
-        response = self.client.post(url, {})
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-
-
-class IntegrationTest(APITestCase):
-    """Integration tests for OTP flow."""
-    
-    
-
-    def setUp(self):
-        self.email = "test@example.com"
-        self.otp_request_url = reverse("otp-request-otp")
-        self.otp_verify_url = reverse("otp-verify-otp")
-
-    @patch("apps.mailer.services.email_service.EmailService.send_templated_email")
-    def test_full_otp_flow(self, mock_email):
-        """Test complete OTP flow."""
-        mock_email.return_value = True
-
-        # Step 1: Request OTP
-        data = {"email": self.email}
-        response = self.client.post(self.otp_request_url, data)
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-
-        # Step 2: Get OTP from database
-        otp = OTPSecret.objects.get(email=self.email)
-        self.assertIsNotNone(otp)
-
-        # Step 3: Verify OTP
-        data = {"email": self.email, "otp": otp.secret}
-        response = self.client.post(self.otp_verify_url, data)
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("access", response.data)
-        self.assertIn("refresh", response.data)
-        self.assertIn("user", response.data)
-
-    @patch("apps.mailer.services.email_service.EmailService.send_templated_email")
-    def test_full_otp_flow_with_source_url(self, mock_email):
-        """Test complete OTP flow with source_url."""
-        mock_email.return_value = True
-
-        # Step 1: Request OTP with source_url
-        data = {"email": self.email, "source_url": "https://reforms.ai"}
-        response = self.client.post(self.otp_request_url, data)
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-
-        # Step 2: Get OTP from database
-        otp = OTPSecret.objects.get(email=self.email)
-        self.assertIsNotNone(otp)
-
-        # Step 3: Verify OTP with source_url
-        data = {
-            "email": self.email,
-            "otp": otp.secret,
-            "source_url": "https://reforms.ai",
-        }
-        response = self.client.post(self.otp_verify_url, data)
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertIn("access", response.data)
-        self.assertIn("refresh", response.data)
-        self.assertIn("user", response.data)

django_cfg/apps/newsletter/tests/__init__.py

@@ -1 +0,0 @@
-# Tests package 

django_cfg/apps/newsletter/tests/run_tests.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to run newsletter manager tests
-"""
-import os
-import sys
-import django
-from django.conf import settings
-
-# Add the project root to Python path
-project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
-sys.path.insert(0, project_root)
-
-# Setup Django
-os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'core.settings')
-django.setup()
-
-# Import and run tests
-from django.test.utils import get_runner
-from django.conf import settings
-
-def run_tests():
-    """Run the newsletter tests"""
-    TestRunner = get_runner(settings)
-    test_runner = TestRunner()
-    
-    # Test modules to run
-    test_modules = [
-        'mailer.tests.test_newsletter_manager',
-        'mailer.tests.test_newsletter_models',
-    ]
-    
-    print("Running Newsletter Manager Tests...")
-    print("=" * 50)
-    
-    failures = test_runner.run_tests(test_modules)
-    
-    if failures:
-        print(f"\n❌ {failures} test(s) failed!")
-        return False
-    else:
-        print("\n✅ All tests passed!")
-        return True
-
-if __name__ == '__main__':
-    success = run_tests()
-    sys.exit(0 if success else 1) 

django_cfg/apps/newsletter/tests/test_email_integration.py

@@ -1,256 +0,0 @@
-"""
-Integration tests for email tracking functionality.
-"""
-
-from django.test import TestCase, Client, override_settings
-from django.contrib.auth import get_user_model
-from django.urls import reverse
-from django.core import mail
-from unittest.mock import patch
-
-from ..models import Newsletter, EmailLog, NewsletterSubscription
-from ..services.email_service import NewsletterEmailService
-
-User = get_user_model()
-
-
-@override_settings(EMAIL_BACKEND='django.core.mail.backends.locmem.EmailBackend')
-class EmailTrackingIntegrationTestCase(TestCase):
-    """Integration tests for email tracking with real email sending"""
-    
-    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='Integration Test Newsletter',
-            description='Test newsletter for integration testing',
-            is_active=True
-        )
-        
-        # Create newsletter subscription
-        NewsletterSubscription.objects.create(
-            user=self.user,
-            newsletter=self.newsletter,
-            email=self.user.email,  # Add email field
-            is_active=True
-        )
-        
-        self.email_service = NewsletterEmailService()
-    
-    def test_send_email_with_tracking_creates_log(self):
-        """Test that sending email with tracking creates EmailLog"""
-        # Clear any existing mail
-        mail.outbox = []
-        
-        # Send email with tracking
-        result = self.email_service.send_bulk_email(
-            recipients=['test@example.com'],
-            subject='Test Email with Tracking',
-            email_title='Test Title',
-            main_text='This is a test email with tracking enabled.',
-            button_text='Click Me',
-            button_url='https://example.com/test',
-            enable_tracking=True,
-            newsletter=self.newsletter
-        )
-        
-        # Check result
-        self.assertEqual(result['sent_count'], 1)
-        self.assertEqual(result['failed_count'], 0)
-        
-        # Check that email was sent
-        self.assertEqual(len(mail.outbox), 1)
-        sent_email = mail.outbox[0]
-        self.assertEqual(sent_email.to, ['test@example.com'])
-        self.assertEqual(sent_email.subject, 'Test Email with Tracking')
-        
-        # Check that EmailLog 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.recipient, 'test@example.com')
-        self.assertEqual(email_log.status, EmailLog.EmailLogStatus.SENT)
-        self.assertIsNotNone(email_log.sent_at)
-        
-        # Check HTML version for tracking (tracking is only in HTML version)
-        self.assertTrue(hasattr(sent_email, 'alternatives') and sent_email.alternatives, 
-                       "Email should have HTML alternative for tracking")
-        
-        html_body = sent_email.alternatives[0][0]
-        self.assertIn('track/open/', html_body)  # Tracking pixel URL
-        self.assertIn('track/click/', html_body)  # Click tracking URL
-        self.assertIn(str(email_log.id), html_body)  # Tracking ID should be in HTML
-    
-    def test_tracking_pixel_marks_email_as_opened(self):
-        """Test that accessing tracking pixel marks email as opened"""
-        # First send an email to create EmailLog
-        result = self.email_service.send_bulk_email(
-            recipients=['test@example.com'],
-            subject='Test Email',
-            email_title='Test',
-            main_text='Test content',
-            enable_tracking=True,
-            newsletter=self.newsletter
-        )
-        
-        # Get the created EmailLog
-        email_log = EmailLog.objects.filter(newsletter=self.newsletter).first()
-        self.assertIsNotNone(email_log)
-        self.assertFalse(email_log.is_opened)
-        
-        # Access tracking pixel
-        tracking_url = reverse('cfg_newsletter:track-open', kwargs={'email_log_id': email_log.id})
-        response = self.client.get(tracking_url)
-        
-        # Check response is a valid image
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response['Content-Type'], 'image/gif')
-        
-        # Check that email is marked as opened
-        email_log.refresh_from_db()
-        self.assertTrue(email_log.is_opened)
-        self.assertIsNotNone(email_log.opened_at)
-    
-    def test_click_tracking_marks_email_as_clicked(self):
-        """Test that click tracking marks email as clicked and redirects"""
-        # First send an email to create EmailLog
-        result = self.email_service.send_bulk_email(
-            recipients=['test@example.com'],
-            subject='Test Email',
-            email_title='Test',
-            main_text='Test content',
-            button_text='Click Here',
-            button_url='https://example.com/destination',
-            enable_tracking=True,
-            newsletter=self.newsletter
-        )
-        
-        # Get the created EmailLog
-        email_log = EmailLog.objects.filter(newsletter=self.newsletter).first()
-        self.assertIsNotNone(email_log)
-        self.assertFalse(email_log.is_clicked)
-        
-        # Access click tracking URL
-        tracking_url = reverse('cfg_newsletter:track-click', kwargs={'email_log_id': email_log.id})
-        tracking_url += '?url=https://example.com/destination'
-        
-        response = self.client.get(tracking_url)
-        
-        # Check redirect response
-        self.assertEqual(response.status_code, 302)
-        self.assertEqual(response.url, 'https://example.com/destination')
-        
-        # Check that email is marked as clicked
-        email_log.refresh_from_db()
-        self.assertTrue(email_log.is_clicked)
-        self.assertIsNotNone(email_log.clicked_at)
-    
-    def test_newsletter_email_sending_with_tracking(self):
-        """Test complete newsletter sending workflow with tracking"""
-        # Clear any existing mail from signals
-        mail.outbox = []
-        
-        # Send newsletter email
-        result = self.email_service.send_newsletter_email(
-            newsletter=self.newsletter,
-            subject='Newsletter Test',
-            email_title='Monthly Newsletter',
-            main_text='This is our monthly newsletter content.',
-            button_text='Read More',
-            button_url='https://example.com/newsletter',
-            send_to_all=True  # Send to all subscribers
-        )
-        
-        # Check result
-        self.assertEqual(result['sent_count'], 1)  # One subscriber
-        self.assertEqual(result['failed_count'], 0)
-        
-        # Check email was sent
-        self.assertEqual(len(mail.outbox), 1)
-        
-        # Check EmailLog 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)
-        
-        # Test tracking functionality
-        # 1. Test open tracking
-        open_url = reverse('cfg_newsletter:track-open', kwargs={'email_log_id': email_log.id})
-        open_response = self.client.get(open_url)
-        self.assertEqual(open_response.status_code, 200)
-        
-        # 2. Test click tracking
-        click_url = reverse('cfg_newsletter:track-click', kwargs={'email_log_id': email_log.id})
-        click_url += '?url=https://example.com/newsletter'
-        click_response = self.client.get(click_url)
-        self.assertEqual(click_response.status_code, 302)
-        
-        # Verify tracking was recorded
-        email_log.refresh_from_db()
-        self.assertTrue(email_log.is_opened)
-        self.assertTrue(email_log.is_clicked)
-        self.assertIsNotNone(email_log.opened_at)
-        self.assertIsNotNone(email_log.clicked_at)
-    
-    def test_multiple_opens_only_record_first_time(self):
-        """Test that multiple opens only record the first timestamp"""
-        # Send email
-        result = self.email_service.send_bulk_email(
-            recipients=['test@example.com'],
-            subject='Test Email',
-            email_title='Test',
-            main_text='Test content',
-            enable_tracking=True,
-            newsletter=self.newsletter
-        )
-        
-        email_log = EmailLog.objects.filter(newsletter=self.newsletter).first()
-        
-        # First open
-        open_url = reverse('cfg_newsletter:track-open', kwargs={'email_log_id': email_log.id})
-        self.client.get(open_url)
-        
-        email_log.refresh_from_db()
-        first_opened_at = email_log.opened_at
-        self.assertIsNotNone(first_opened_at)
-        
-        # Second open (should not change timestamp)
-        self.client.get(open_url)
-        
-        email_log.refresh_from_db()
-        self.assertEqual(email_log.opened_at, first_opened_at)
-    
-    def test_tracking_with_invalid_email_log_id(self):
-        """Test tracking with invalid email log ID handles gracefully"""
-        import uuid
-        
-        # Test open tracking with invalid ID
-        invalid_id = uuid.uuid4()
-        open_url = reverse('cfg_newsletter:track-open', kwargs={'email_log_id': invalid_id})
-        open_response = self.client.get(open_url)
-        
-        # Should still return tracking pixel
-        self.assertEqual(open_response.status_code, 200)
-        self.assertEqual(open_response['Content-Type'], 'image/gif')
-        
-        # Test click tracking with invalid ID
-        click_url = reverse('cfg_newsletter:track-click', kwargs={'email_log_id': invalid_id})
-        click_url += '?url=https://example.com/test'
-        click_response = self.client.get(click_url)
-        
-        # Should still redirect
-        self.assertEqual(click_response.status_code, 302)
-        self.assertEqual(click_response.url, 'https://example.com/test')