init

backend/tests/unit/test_payments.py

@@ -0,0 +1,194 @@
+import uuid
+from datetime import timedelta
+from types import SimpleNamespace
+
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+from django.utils import timezone
+
+from django.contrib.admin import AdminSite
+from payments.admin import DiscountCodeAdmin
+from payments.models import DiscountCode, Payment
+from payments.resources import DiscountResource, PaymentResource
+from events.models import Event
+from users.models import User
+from ninja.errors import HttpError
+
+
+class PaymentTestMixin:
+    @staticmethod
+    def _create_user(**overrides):
+        data = {
+            "username": f"user_{uuid.uuid4().hex[:6]}",
+            "email": f"user_{uuid.uuid4().hex[:6]}@example.com",
+            "password": "Test!1234",
+        }
+        data.update(overrides)
+        return User.objects.create_user(**data)
+
+    @staticmethod
+    def _create_event(**overrides):
+        now = timezone.now()
+        defaults = {
+            "title": "Sample",
+            "description": "Desc",
+            "start_time": now,
+            "end_time": now + timedelta(hours=2),
+            "registration_start_date": now - timedelta(days=1),
+            "registration_end_date": now + timedelta(days=5),
+            "slug": f"event-{uuid.uuid4().hex[:6]}",
+            "price": 100000,
+            "capacity": 10,
+            "status": Event.StatusChoices.PUBLISHED,
+        }
+        defaults.update(overrides)
+        return Event.objects.create(**defaults)
+
+    @staticmethod
+    def _discount_code(**overrides):
+        defaults = {
+            "code": f"CODE{uuid.uuid4().hex[:4]}",
+            "value": 50,
+            "is_active": True,
+            "type": DiscountCode.Type.PERCENT,
+        }
+        defaults.update(overrides)
+        return DiscountCode.objects.create(**defaults)
+
+
+class DiscountCodeModelTests(TestCase, PaymentTestMixin):
+    def setUp(self):
+        self.event = self._create_event()
+        self.user = self._create_user(is_email_verified=True)
+
+    def test_zero_price_returns_zero_discount(self):
+        event = self._create_event(price=0)
+        code = self._discount_code()
+        code.applicable_events.add(event)
+        self.assertEqual(code.calculate_discount(event, self.user), (0, 0))
+
+    def test_inactive_raises_error(self):
+        code = self._discount_code(is_active=False)
+        code.applicable_events.add(self.event)
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_start_date_validation(self):
+        code = self._discount_code(starts_at=timezone.now() + timedelta(days=1))
+        code.applicable_events.add(self.event)
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_end_date_validation(self):
+        code = self._discount_code(ends_at=timezone.now() - timedelta(days=1))
+        code.applicable_events.add(self.event)
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_applicable_events_enforcement(self):
+        code = self._discount_code()
+        other_event = self._create_event()
+        code.applicable_events.add(other_event)
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_min_amount_guard(self):
+        code = self._discount_code(min_amount=200000)
+        code.applicable_events.add(self.event)
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_usage_limit_total(self):
+        code = self._discount_code(usage_limit_total=1)
+        code.applicable_events.add(self.event)
+        Payment.objects.create(
+            user=self.user,
+            event=self.event,
+            base_amount=self.event.price,
+            amount=self.event.price,
+            discount_amount=0,
+            status=Payment.OrderStatusChoices.PAID,
+            discount_code=code,
+        )
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_usage_limit_per_user(self):
+        code = self._discount_code(usage_limit_per_user=1)
+        code.applicable_events.add(self.event)
+        Payment.objects.create(
+            user=self.user,
+            event=self.event,
+            base_amount=self.event.price,
+            amount=self.event.price,
+            discount_amount=0,
+            status=Payment.OrderStatusChoices.PENDING,
+            discount_code=code,
+        )
+        with self.assertRaises(HttpError):
+            code.calculate_discount(self.event, self.user)
+
+    def test_final_price_below_min_post_discount(self):
+        event = self._create_event(price=15000)
+        code = self._discount_code(value=80)
+        code.applicable_events.add(event)
+        with self.assertRaises(HttpError):
+            code.calculate_discount(event, self.user)
+
+    def test_fixed_discount_type(self):
+        code = self._discount_code(type=DiscountCode.Type.FIXED, value=5000)
+        code.applicable_events.add(self.event)
+        final, disc = code.calculate_discount(self.event, self.user)
+        self.assertEqual(disc, 5000)
+        self.assertEqual(final, self.event.price - 5000)
+
+
+class PaymentModelAndResourceTests(TestCase, PaymentTestMixin):
+    def setUp(self):
+        self.event = self._create_event()
+        self.user = self._create_user(is_email_verified=True)
+
+    def test_payment_clean_validates_amount(self):
+        payment = Payment(
+            user=self.user,
+            event=self.event,
+            base_amount=1000,
+            amount=500,
+            discount_amount=400,
+            status=Payment.OrderStatusChoices.INIT,
+        )
+        with self.assertRaises(ValidationError):
+            payment.full_clean()
+
+    def test_payment_resource_defers_user_event(self):
+        payment = Payment.objects.create(
+            user=self.user,
+            event=self.event,
+            base_amount=1000,
+            amount=1000,
+            discount_amount=0,
+            status=Payment.OrderStatusChoices.INIT,
+        )
+        resource = PaymentResource()
+        user_cell = resource.fields["user"].widget.clean(self.user.username, None)
+        self.assertEqual(user_cell, self.user)
+        event_cell = resource.fields["event"].widget.clean(self.event.title, None)
+        self.assertEqual(event_cell, self.event)
+
+    def test_discount_resource_expands_events(self):
+        resource = DiscountResource()
+        widget = resource.fields["event"].widget
+        self.assertEqual(widget.separator, "||")
+
+
+class DiscountCodeAdminTests(TestCase, PaymentTestMixin):
+    def setUp(self):
+        self.admin = DiscountCodeAdmin(DiscountCode, AdminSite())
+
+    def test_deactivate_codes_action(self):
+        code = self._discount_code()
+        queryset = DiscountCode.objects.filter(pk=code.pk)
+        request = SimpleNamespace(_messages=SimpleNamespace(add=lambda *args, **kwargs: None))
+        self.admin.deactivate_codes(request, queryset)
+        code.refresh_from_db()
+        self.assertFalse(code.is_active)

backend/tests/unit/test_users.py

@@ -0,0 +1,400 @@
+import uuid
+from datetime import timedelta
+from unittest import mock
+
+from django.db.models.signals import post_save
+from django.test import SimpleTestCase, TestCase, override_settings
+from django.utils import timezone
+
+from import_export.widgets import BooleanWidget
+
+from users.models import User, Major, University
+from users.resources import UserResource
+from users.signals import send_verification_email_on_registration
+from users.tasks import (
+    send_email_verified_success,
+    send_password_reset_email,
+    send_verification_email,
+)
+
+
+class UserFactoryMixin:
+    def _ensure_reference_objects(self):
+        if not hasattr(self, "_default_major"):
+            self._default_major, _ = Major.objects.get_or_create(
+                code="CS",
+                defaults={"name": "Computer Science"},
+            )
+            self._default_university, _ = University.objects.get_or_create(
+                code="UT",
+                defaults={"name": "University of Tehran"},
+            )
+
+    def _resolve_major(self, value):
+        if value is None:
+            return None
+        if isinstance(value, Major):
+            return value
+        obj, _ = Major.objects.get_or_create(code=value, defaults={"name": value})
+        return obj
+
+    def _resolve_university(self, value):
+        if value is None:
+            return None
+        if isinstance(value, University):
+            return value
+        obj, _ = University.objects.get_or_create(code=value, defaults={"name": value})
+        return obj
+
+    def create_user(self, **extra_fields):
+        self._ensure_reference_objects()
+        unique = uuid.uuid4().hex
+        data = {
+            "email": f"user_{unique}@example.com",
+            "username": f"user_{unique[:10]}",
+            "first_name": "Test",
+            "last_name": "User",
+        }
+        password = extra_fields.pop("password", "StrongPass!123")
+        major = extra_fields.pop("major", self._default_major)
+        university = extra_fields.pop("university", self._default_university)
+        if isinstance(major, str):
+            major = self._resolve_major(major)
+        if isinstance(university, str):
+            university = self._resolve_university(university)
+        data.update(extra_fields)
+        data.setdefault("major", major)
+        data.setdefault("university", university)
+        return User.objects.create_user(password=password, **data)
+
+
+class UserModelTests(UserFactoryMixin, TestCase):
+    def setUp(self):
+        super().setUp()
+        patcher = mock.patch("users.signals.send_verification_email.delay")
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_str_returns_full_name_with_email(self):
+        # Arrange
+        user = self.create_user(first_name="Ada", last_name="Lovelace")
+
+        # Act
+        result = str(user)
+
+        # Assert
+        expected = f"{user.get_full_name()} ({user.email})"
+        self.assertEqual(result, expected)
+
+    def test_get_full_name_handles_missing_names(self):
+        # Arrange
+        user = self.create_user(first_name="Grace", last_name="")
+
+        # Act
+        result = user.get_full_name()
+
+        # Assert
+        self.assertEqual(result, "Grace")
+
+    def test_regenerate_verification_token_generates_new_value(self):
+        # Arrange
+        user = self.create_user()
+        original_token = user.email_verification_token
+
+        # Act
+        user.regenerate_verification_token()
+
+        # Assert
+        self.assertNotEqual(user.email_verification_token, original_token)
+
+    def test_set_password_reset_token_assigns_future_expiry(self):
+        # Arrange
+        user = self.create_user()
+        frozen = timezone.now()
+
+        # Act
+        with mock.patch("users.models.timezone.now", return_value=frozen):
+            user.set_password_reset_token()
+
+        # Assert
+        self.assertIsNotNone(user.password_reset_token)
+        self.assertEqual(
+            user.password_reset_token_expires_at,
+            frozen + timedelta(hours=1),
+        )
+
+    def test_save_triggers_verified_task_on_state_change(self):
+        # Arrange
+        user = self.create_user()
+
+        # Act
+        with mock.patch("users.tasks.send_email_verified_success.delay") as mock_delay:
+            user.is_email_verified = True
+            user.save()
+
+        # Assert
+        mock_delay.assert_called_once_with(user.id)
+
+    def test_save_skips_task_when_already_verified(self):
+        # Arrange
+        user = self.create_user(is_email_verified=True)
+
+        # Act
+        with mock.patch("users.tasks.send_email_verified_success.delay") as mock_delay:
+            user.bio = "Updated bio"
+            user.save()
+
+        # Assert
+        mock_delay.assert_not_called()
+
+
+class UserSignalTests(TestCase):
+    def setUp(self):
+        super().setUp()
+        post_save.disconnect(send_verification_email_on_registration, sender=User)
+        self.addCleanup(
+            post_save.connect,
+            send_verification_email_on_registration,
+            User,
+            False,
+        )
+
+    @override_settings(FRONTEND_ROOT="https://frontend.example/")
+    @mock.patch("users.signals.send_verification_email.delay")
+    @mock.patch("users.signals.uuid.uuid4")
+    def test_signal_sets_username_timestamp_and_dispatches_email(
+        self,
+        mock_uuid,
+        mock_delay,
+    ):
+        # Arrange
+        fake_uuid = uuid.UUID("12345678-1234-5678-1234-567812345678")
+        mock_uuid.return_value = fake_uuid
+        fake_now = timezone.now()
+        user = User.objects.create(
+            email="new.user@example.com",
+            username="",
+            password="pass",
+            is_email_verified=False,
+        )
+
+        # Act
+        with mock.patch("users.signals.timezone.now", return_value=fake_now):
+            send_verification_email_on_registration(User, user, created=True)
+
+        # Assert
+        user.refresh_from_db()
+        self.assertEqual(user.username, str(fake_uuid)[:10])
+        self.assertEqual(user.email_verification_sent_at, fake_now)
+        expected_url = (
+            f"https://frontend.example/verify-email/{user.email_verification_token}"
+        )
+        mock_delay.assert_called_once_with(user.id, expected_url)
+
+    @override_settings(FRONTEND_ROOT="https://frontend.example/")
+    @mock.patch("users.signals.send_verification_email.delay")
+    def test_signal_preserves_existing_username(self, mock_delay):
+        # Arrange
+        fake_now = timezone.now()
+        user = User.objects.create(
+            email="existing@example.com",
+            username="existing_name",
+            password="pass",
+            is_email_verified=False,
+        )
+
+        # Act
+        with mock.patch("users.signals.timezone.now", return_value=fake_now):
+            send_verification_email_on_registration(User, user, created=True)
+
+        # Assert
+        user.refresh_from_db()
+        self.assertEqual(user.username, "existing_name")
+        self.assertEqual(user.email_verification_sent_at, fake_now)
+        mock_delay.assert_called_once()
+
+    @mock.patch("users.signals.send_verification_email.delay")
+    def test_signal_skips_when_user_already_verified(self, mock_delay):
+        # Arrange
+        user = User.objects.create(
+            email="verified@example.com",
+            username="verified_user",
+            password="pass",
+            is_email_verified=True,
+        )
+
+        # Act
+        send_verification_email_on_registration(User, user, created=True)
+
+        # Assert
+        self.assertIsNone(user.email_verification_sent_at)
+        mock_delay.assert_not_called()
+
+    @mock.patch("users.signals.send_verification_email.delay")
+    def test_signal_skips_when_email_missing(self, mock_delay):
+        # Arrange
+        user = User.objects.create(
+            email="",
+            username="no_email",
+            password="pass",
+            is_email_verified=False,
+        )
+
+        # Act
+        send_verification_email_on_registration(User, user, created=True)
+
+        # Assert
+        self.assertIsNone(user.email_verification_sent_at)
+        mock_delay.assert_not_called()
+
+    @mock.patch("users.signals.send_verification_email.delay")
+    def test_signal_ignores_updates_to_existing_users(self, mock_delay):
+        # Arrange
+        user = User.objects.create(
+            email="existing-update@example.com",
+            username="existing_update",
+            password="pass",
+            is_email_verified=False,
+        )
+
+        # Act
+        send_verification_email_on_registration(User, user, created=False)
+
+        # Assert
+        self.assertIsNone(user.email_verification_sent_at)
+        mock_delay.assert_not_called()
+
+
+class UserTaskTests(UserFactoryMixin, TestCase):
+    def setUp(self):
+        super().setUp()
+        patcher = mock.patch("users.signals.send_verification_email.delay")
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    @override_settings(DEFAULT_FROM_EMAIL="no-reply@example.com")
+    @mock.patch("users.tasks.send_mail")
+    @mock.patch("users.tasks.render_to_string", return_value="<p>Hi</p>")
+    def test_send_verification_email_task_sends_expected_payload(
+        self,
+        mock_render,
+        mock_send_mail,
+    ):
+        # Arrange
+        user = self.create_user()
+        verification_url = "https://example.com/verify"
+
+        # Act
+        result = send_verification_email.run(user.id, verification_url)
+
+        # Assert
+        self.assertEqual(result, f"Verification email sent to {user.email}")
+        mock_render.assert_called_once_with(
+            "emails/verification_email.html",
+            {"user": user, "verification_url": verification_url},
+        )
+        kwargs = mock_send_mail.call_args.kwargs
+        self.assertEqual(kwargs["recipient_list"], [user.email])
+        self.assertEqual(kwargs["from_email"], "no-reply@example.com")
+        self.assertEqual(kwargs["message"], "Hi")
+
+    @override_settings(DEFAULT_FROM_EMAIL="support@example.com")
+    @mock.patch("users.tasks.send_mail")
+    @mock.patch("users.tasks.render_to_string", return_value="<p>Reset</p>")
+    def test_send_password_reset_email_task_uses_reset_template(
+        self,
+        mock_render,
+        mock_send_mail,
+    ):
+        # Arrange
+        user = self.create_user()
+        reset_url = "https://example.com/reset"
+
+        # Act
+        result = send_password_reset_email.run(user.id, reset_url)
+
+        # Assert
+        self.assertEqual(result, f"Password reset email sent to {user.email}")
+        mock_render.assert_called_once_with(
+            "emails/password_reset_email.html",
+            {"user": user, "reset_url": reset_url},
+        )
+        kwargs = mock_send_mail.call_args.kwargs
+        self.assertEqual(kwargs["recipient_list"], [user.email])
+        self.assertEqual(kwargs["from_email"], "support@example.com")
+        self.assertEqual(kwargs["message"], "Reset")
+
+    @override_settings(
+        DEFAULT_FROM_EMAIL="success@example.com",
+        FRONTEND_ROOT="https://frontend.example/",
+    )
+    @mock.patch("users.tasks.send_mail")
+    @mock.patch("users.tasks.render_to_string", return_value="<p>Success</p>")
+    def test_send_email_verified_success_task_renders_success_template(
+        self,
+        mock_render,
+        mock_send_mail,
+    ):
+        # Arrange
+        user = self.create_user()
+
+        # Act
+        result = send_email_verified_success.run(user.id)
+
+        # Assert
+        self.assertEqual(result, f"verified success email sent to {user.email}")
+        mock_render.assert_called_once_with(
+            "emails/verification_success.html",
+            {"user": user, "home_url": "https://frontend.example/"},
+        )
+        kwargs = mock_send_mail.call_args.kwargs
+        self.assertEqual(kwargs["recipient_list"], [user.email])
+        self.assertEqual(kwargs["from_email"], "success@example.com")
+        self.assertEqual(kwargs["message"], "Success")
+
+    def test_send_verification_email_task_retries_on_lookup_error(self):
+        # Arrange
+        retry_patch = mock.patch.object(
+            send_verification_email,
+            "retry",
+            side_effect=RuntimeError("retry"),
+        )
+
+        # Act / Assert
+        with mock.patch(
+            "users.tasks.User.objects.get",
+            side_effect=ValueError("missing"),
+        ), retry_patch as mock_retry:
+            with self.assertRaises(RuntimeError):
+                send_verification_email.run(999, "https://example.com/verify")
+
+        self.assertEqual(mock_retry.call_args.kwargs.get("countdown"), 60)
+        self.assertIsInstance(mock_retry.call_args.kwargs.get("exc"), ValueError)
+
+
+class UserResourceTests(SimpleTestCase):
+    def test_boolean_fields_use_boolean_widget(self):
+        # Arrange
+        resource = UserResource()
+
+        # Act
+        widgets = [
+            resource.fields["is_staff"].widget,
+            resource.fields["is_superuser"].widget,
+            resource.fields["is_email_verified"].widget,
+        ]
+
+        # Assert
+        for widget in widgets:
+            self.assertIsInstance(widget, BooleanWidget)
+
+    def test_field_order_matches_meta_definition(self):
+        # Arrange
+        resource = UserResource()
+
+        # Act
+        field_names = tuple(resource.fields.keys())
+
+        # Assert
+        self.assertEqual(resource._meta.export_order, resource._meta.fields)
+        self.assertSetEqual(set(field_names), set(resource._meta.fields))