Reformat more tests in models

Author: adamspd

appointment/models.py

@@ -10,6 +10,7 @@
 import random
 import string
 import uuid
+from decimal import Decimal, InvalidOperation
 
 from babel.numbers import get_currency_symbol
 from django.conf import settings
@@ -435,7 +436,7 @@ class Appointment(models.Model):
     want_reminder = models.BooleanField(default=False)
     additional_info = models.TextField(blank=True, null=True)
     paid = models.BooleanField(default=False)
-    amount_to_pay = models.DecimalField(max_digits=6, decimal_places=2, blank=True, null=True)
+    amount_to_pay = models.DecimalField(max_digits=10, decimal_places=2, blank=True, null=True)
     id_request = models.CharField(max_length=100, blank=True, null=True)
 
     # meta datas
@@ -453,16 +454,30 @@ def save(self, *args, **kwargs):
 
         if self.id_request is None:
             self.id_request = f"{get_timestamp()}{self.appointment_request.id}{generate_random_id()}"
-        if self.amount_to_pay is None or self.amount_to_pay == 0:
-            payment_type = self.appointment_request.payment_type
-            if payment_type == 'full':
-                self.amount_to_pay = self.appointment_request.get_service_price()
-            elif payment_type == 'down':
-                self.amount_to_pay = self.appointment_request.get_service_down_payment()
-            else:
-                self.amount_to_pay = 0
+
+        try:
+            # Ensure `amount_to_pay` is a Decimal and handle both int and float inputs
+            if self.amount_to_pay is None:
+                self.amount_to_pay = self._calculate_amount_to_pay()
+
+            self.amount_to_pay = self._to_decimal(self.amount_to_pay)
+        except InvalidOperation:
+            raise ValidationError("Invalid amount format for payment.")
+
         return super().save(*args, **kwargs)
 
+    def _calculate_amount_to_pay(self):
+        payment_type = self.appointment_request.payment_type
+        if payment_type == 'full':
+            return self.appointment_request.get_service_price()
+        elif payment_type == 'down':
+            return self.appointment_request.get_service_down_payment()
+        else:
+            return Decimal('0.00')
+
+    def _to_decimal(self, value):
+        return Decimal(f"{value}").quantize(Decimal('0.01'))
+
     def get_client_name(self):
         if hasattr(self.client, 'get_full_name') and callable(getattr(self.client, 'get_full_name')):
             name = self.client.get_full_name()
@@ -664,6 +679,10 @@ def clean(self):
         if self.lead_time is not None and self.finish_time is not None:
             if self.lead_time >= self.finish_time:
                 raise ValidationError(_("Lead time must be before finish time"))
+        if self.appointment_buffer_time is not None and self.appointment_buffer_time < 0:
+            raise ValidationError(_("Appointment buffer time cannot be negative"))
+        if self.slot_duration is not None and self.slot_duration <= 0:
+            raise ValidationError(_("Slot duration must be greater than 0"))
 
     def save(self, *args, **kwargs):
         self.clean()

appointment/tests/base/base_test.py

@@ -54,13 +54,17 @@ def clean_all_data(cls):
         Service.objects.all().delete()
         get_user_model().objects.all().delete()
 
-    def create_appt_request_for_sm1(self, **kwargs):
+    def create_appt_request_for_sm1(self, service=None, staff_member=None, **kwargs):
         """Create an appointment request for staff_member1."""
-        return self.create_appointment_request_(service=self.service1, staff_member=self.staff_member1, **kwargs)
+        service = service or self.service1
+        staff_member = staff_member or self.staff_member1
+        return self.create_appointment_request_(service=service, staff_member=staff_member, **kwargs)
 
-    def create_appt_request_for_sm2(self, **kwargs):
+    def create_appt_request_for_sm2(self, service=None, staff_member=None, **kwargs):
         """Create an appointment request for staff_member2."""
-        return self.create_appointment_request_(service=self.service2, staff_member=self.staff_member2, **kwargs)
+        service = service or self.service2
+        staff_member = staff_member or self.staff_member2
+        return self.create_appointment_request_(service=service, staff_member=staff_member, **kwargs)
 
     def create_appt_for_sm1(self, appointment_request=None):
         if not appointment_request:

appointment/tests/mixins/base_mixin.py

@@ -72,7 +72,7 @@ def __init__(self):
         pass
 
     @classmethod
-    def create_appointment_(cls, user, appointment_request, phone="1234567890",
+    def create_appointment_(cls, user, appointment_request, phone="+12392340543",
                             address="Stargate Command, Cheyenne Mountain Complex, Colorado Springs, CO"):
         return Appointment.objects.create(
             client=user,

appointment/tests/models/test_appointment_request.py

@@ -0,0 +1,182 @@
+from copy import deepcopy
+from datetime import date, datetime, time, timedelta
+
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from appointment.tests.base.base_test import BaseTest
+
+
+class AppointmentRequestCreationAndBasicAttributesTests(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        return super().setUpTestData()
+
+    @classmethod
+    def tearDownClass(cls):
+        return super().tearDownClass()
+
+    def setUp(self) -> None:
+        self.ar = self.create_appt_request_for_sm1()
+        return super().setUp()
+
+    def tearDown(self):
+        self.ar.delete()
+        super().tearDown()
+
+    def test_appointment_request_is_properly_created(self):
+        self.assertIsNotNone(self.ar)
+        self.assertEqual(self.ar.service, self.service1)
+        self.assertEqual(self.ar.staff_member, self.staff_member1)
+        self.assertEqual(self.ar.start_time, time(9, 0))
+        self.assertEqual(self.ar.end_time, time(10, 0))
+        self.assertIsNotNone(self.ar.get_id_request())
+        self.assertEqual(self.ar.date, timezone.now().date())
+        self.assertTrue(isinstance(self.ar.get_id_request(), str))
+        self.assertIsNotNone(self.ar.created_at)
+        self.assertIsNotNone(self.ar.updated_at)
+
+    def test_appointment_request_initial_state(self):
+        """Check the initial state of "reschedule attempts" and string representation."""
+        self.assertEqual(self.ar.reschedule_attempts, 0)
+        expected_representation = f"{self.ar.date} - {self.ar.start_time} to {self.ar.end_time} - {self.ar.service.name}"
+        self.assertEqual(str(self.ar), expected_representation)
+
+
+class AppointmentRequestServiceAttributesTests(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        return super().setUpTestData()
+
+    @classmethod
+    def tearDownClass(cls):
+        return super().tearDownClass()
+
+    def setUp(self) -> None:
+        self.ar = self.create_appt_request_for_sm1()
+        return super().setUp()
+
+    def tearDown(self):
+        self.ar.delete()
+        super().tearDown()
+
+    def test_service_related_attributes_are_correct(self):
+        """Validate attributes related to the service within an appointment request."""
+        self.assertEqual(self.ar.get_service_name(), self.service1.name)
+        self.assertEqual(self.ar.get_service_price(), self.service1.get_price())
+        self.assertEqual(self.ar.get_service_down_payment(), self.service1.get_down_payment())
+        self.assertEqual(self.ar.get_service_image(), self.service1.image)
+        self.assertEqual(self.ar.get_service_image_url(), self.service1.get_image_url())
+        self.assertEqual(self.ar.get_service_description(), self.service1.description)
+        self.assertTrue(self.ar.is_a_paid_service())
+        self.assertEqual(self.ar.payment_type, 'full')
+        self.assertFalse(self.ar.accepts_down_payment())
+
+
+class AppointmentRequestAttributeValidation(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        return super().setUpTestData()
+
+    @classmethod
+    def tearDownClass(cls):
+        return super().tearDownClass()
+
+    def setUp(self) -> None:
+        self.ar = self.create_appt_request_for_sm1()
+        return super().setUp()
+
+    def tearDown(self):
+        self.ar.delete()
+        super().tearDown()
+
+    def test_appointment_request_time_validations(self):
+        """Ensure start and end times are validated correctly."""
+        ar = deepcopy(self.ar)
+
+        # End time before start time
+        ar.start_time = time(11, 0)
+        ar.end_time = time(9, 0)
+        with self.assertRaises(ValidationError):
+            ar.full_clean()
+
+        # End time equal to start time
+        ar.end_time = time(11, 0)
+        with self.assertRaises(ValidationError):
+            ar.full_clean()
+
+        with self.assertRaises(ValidationError, msg="Start time and end time cannot be the same"):
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=date.today(), start_time=time(10, 0), end_time=time(10, 0)
+            )
+
+    def test_appointment_request_date_validations(self):
+        """Validate that appointment requests cannot be in the past or have invalid durations."""
+        ar = deepcopy(self.ar)
+
+        past_date = date.today() - timedelta(days=30)
+        ar.date = past_date
+        with self.assertRaises(ValidationError):
+            ar.full_clean()
+
+        with self.assertRaises(ValidationError, msg="Date cannot be in the past"):
+            self.create_appointment_request_(self.service1, self.staff_member1, date_=past_date)
+
+        with self.assertRaises(ValidationError, msg="The date is not valid"):
+            date_ = datetime.strptime("31-03-2021", "%d-%m-%Y").date()
+            self.create_appointment_request_(
+                self.service1, self.staff_member1, date_=date_)
+
+    def test_appointment_duration_exceeds_service_time(self):
+        """Test that an appointment cannot be created with a duration greater than the service duration."""
+        long_duration = timedelta(hours=3)
+        service = self.create_service_(name="Asgard Technology Retrofit", duration=long_duration)
+        service.duration = long_duration
+        service.save()
+
+        # Create an appointment request with a 4-hour duration and the 3-hour service (should not work)
+        with self.assertRaises(ValidationError):
+            self.create_appointment_request_(service, self.staff_member1, start_time=time(9, 0),
+                                             end_time=time(13, 0))
+
+    def test_invalid_payment_type_raises_error(self):
+        """Payment type must be either 'full' or 'down'"""
+        ar = deepcopy(self.ar)
+        ar.payment_type = "Naquadah Instead of Credits"
+        with self.assertRaises(ValidationError):
+            ar.full_clean()
+
+
+class AppointmentRequestRescheduleHistory(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        return super().setUpTestData()
+
+    @classmethod
+    def tearDownClass(cls):
+        return super().tearDownClass()
+
+    def setUp(self) -> None:
+        service = deepcopy(self.service1)
+        service.reschedule_limit = 2
+        service.allow_rescheduling = True
+        service.save()
+        self.ar_ = self.create_appt_request_for_sm1(service=service)
+        return super().setUp()
+
+    def test_ar_can_be_reschedule(self):
+        self.assertTrue(self.ar_.can_be_rescheduled())
+
+    def test_reschedule_attempts_increment(self):
+        self.assertTrue(self.ar_.can_be_rescheduled())
+        self.ar_.increment_reschedule_attempts()
+        self.assertEqual(self.ar_.reschedule_attempts, 1)
+        self.assertTrue(self.ar_.can_be_rescheduled())
+        self.ar_.increment_reschedule_attempts()
+        self.assertEqual(self.ar_.reschedule_attempts, 2)
+        self.assertFalse(self.ar_.can_be_rescheduled())
+
+    def test_no_reschedule_history(self):
+        service = deepcopy(self.service1)
+        ar = self.create_appointment_request_(service, self.staff_member1)
+        self.assertFalse(ar.get_reschedule_history().exists())

appointment/tests/models/test_appointment_reschedule_history.py

@@ -0,0 +1,112 @@
+from datetime import timedelta
+
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from appointment.models import AppointmentRescheduleHistory
+from appointment.tests.base.base_test import BaseTest
+
+
+class AppointmentRescheduleHistoryCreationTests(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+
+    def setUp(self):
+        self.appointment_request = self.create_appt_request_for_sm1()
+        self.future_date = timezone.now().date() + timedelta(days=3)
+        return super().setUp()
+
+    def test_reschedule_history_creation_with_valid_data(self):
+        reschedule_history = AppointmentRescheduleHistory.objects.create(
+            appointment_request=self.appointment_request,
+            date=self.future_date,
+            start_time=timezone.now().time(),
+            end_time=(timezone.now() + timedelta(hours=1)).time(),
+            staff_member=self.staff_member1,
+            reason_for_rescheduling="Client request",
+            reschedule_status='pending'
+        )
+        self.assertIsNotNone(reschedule_history)
+        self.assertEqual(reschedule_history.reschedule_status, 'pending')
+        self.assertTrue(reschedule_history.still_valid())
+
+    def test_auto_generation_of_id_request_on_creation(self):
+        reschedule_history = AppointmentRescheduleHistory.objects.create(
+            appointment_request=self.appointment_request,
+            date=self.future_date,
+            start_time=timezone.now().time(),
+            end_time=(timezone.now() + timedelta(hours=1)).time(),
+            staff_member=self.staff_member1
+        )
+        self.assertIsNotNone(reschedule_history.id_request)
+
+
+class AppointmentRescheduleHistoryValidationTests(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        cls.past_date = timezone.now().date() - timedelta(days=3)
+        cls.future_date = timezone.now().date() + timedelta(days=3)
+
+    def setUp(self):
+        self.appointment_request = self.create_appt_request_for_sm1()
+
+    def test_creation_with_past_date_raises_validation_error(self):
+        with self.assertRaises(ValidationError):
+            AppointmentRescheduleHistory.objects.create(
+                appointment_request=self.appointment_request,
+                date=self.past_date,
+                start_time=timezone.now().time(),
+                end_time=(timezone.now() + timedelta(hours=1)).time(),
+                staff_member=self.staff_member1
+            )
+
+    def test_invalid_date_format_raises_type_error(self):
+        with self.assertRaises(TypeError):
+            AppointmentRescheduleHistory.objects.create(
+                appointment_request=self.appointment_request,
+                date="invalid-date",
+                start_time=timezone.now().time(),
+                end_time=(timezone.now() + timedelta(hours=1)).time(),
+                staff_member=self.staff_member1
+            )
+
+
+class AppointmentRescheduleHistoryTimingTests(BaseTest):
+    @classmethod
+    def setUpTestData(cls):
+        return super().setUpTestData()
+
+    def setUp(self):
+        self.appointment_request = self.create_appt_request_for_sm1()
+        self.future_date = timezone.now().date() + timedelta(days=3)
+        return super().setUp()
+
+    def test_still_valid_within_time_frame(self):
+        reschedule_history = AppointmentRescheduleHistory.objects.create(
+            appointment_request=self.appointment_request,
+            date=self.future_date,
+            start_time=timezone.now().time(),
+            end_time=(timezone.now() + timedelta(hours=1)).time(),
+            staff_member=self.staff_member1,
+            reason_for_rescheduling="Client request",
+            reschedule_status='pending'
+        )
+        self.assertTrue(reschedule_history.still_valid())
+
+    def test_still_valid_outside_time_frame(self):
+        reschedule_history = AppointmentRescheduleHistory.objects.create(
+            appointment_request=self.appointment_request,
+            date=self.future_date,
+            start_time=timezone.now().time(),
+            end_time=(timezone.now() + timedelta(hours=1)).time(),
+            staff_member=self.staff_member1,
+            reason_for_rescheduling="Client request",
+            reschedule_status='pending'
+        )
+        self.assertTrue(reschedule_history.still_valid())
+        # Simulate passage of time beyond the validity window
+        reschedule_history.created_at -= timedelta(minutes=6)
+        reschedule_history.save()
+        self.assertFalse(reschedule_history.still_valid())