def test_two_appointments_not_overlapping(self):
"""
Two appointments where the start and end time are not overlapping and not close to each other should not
cause issues
"""
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
data['start'] = next_tuesday().replace(hour=9, minute=45)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
def test_two_appointments_start_on_end_of_previous(self):
"""
Appointment starts on the same minute another one has finished
Should create Appointment
"""
data = self.data()
# Starts at 9 finishes at 9:30
data['start'] = next_tuesday().replace(hour=9, minute=0)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
# Starts at 9:30 (the end of previous appointment)
data['start'] = next_tuesday().replace(hour=9, minute=30)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
def test_appointment_finishing_in_middle_of_another_canceled(self):
"""
Booking an appointment that starts at another end and finishes at another start
:return:
"""
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=30)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
reject_appointment(appointment)
data['start'] = next_tuesday().replace(hour=9, minute=15)
self.assertIsInstance(book_appointment(**data), Appointment)
def test_two_appointments_end_on_start_of_previous(self):
"""
When a appointment ends on the same minute another one has started
this should not fail
"""
data = self.data()
# Start at 9:45
data['start'] = next_tuesday().replace(hour=9, minute=45)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
# Starts at 9:15 finishes at 9:45 (start of previous appointment)
data['start'] = next_tuesday().replace(hour=9, minute=15)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
def test_appointment_between_2_appointments_exact_times(self):
"""
Booking an appointment that starts at another end and finishes at another start
:return:
"""
print('test_appointment_between_2_appointments_exact_times')
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
self.assertIsInstance(book_appointment(**data), Appointment)
data['start'] = next_tuesday().replace(hour=10, minute=0)
self.assertIsInstance(book_appointment(**data), Appointment)
data['start'] = next_tuesday().replace(hour=9, minute=30)
self.assertIsInstance(book_appointment(**data), Appointment)
def test_appointment_end_a_minute_after_next_starts_ignore_availability_true(
self):
"""
Two appointments where the second finishes a minute after the previous started
Should raise Validation Error
"""
data = self.data()
# Start at 9:45
data['start'] = next_tuesday().replace(hour=9, minute=45)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
# Starts at 9:16 finishes at 9:46 (a minute after previous started)
data['start'] = next_tuesday().replace(hour=9, minute=16)
appointment = book_appointment(**data, ignore_availability=True)
self.assertIsInstance(appointment, Appointment)
def test_two_appointments_start_a_minute_before_end_of_previous_ignore_availability_true(
self):
"""
Appointment starts a minute before previous appointment has finished
with ignore_availability set to True
Should create appointment
"""
data = self.data()
# Starts at 9 finishes at 9:30
data['start'] = next_tuesday().replace(hour=9, minute=0)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
# Starts at 9:29 (the end of previous appointment)
data['start'] = next_tuesday().replace(hour=9, minute=29)
appointment = book_appointment(**data, ignore_availability=True)
self.assertIsInstance(appointment, Appointment)
def test_soft_delete_appointment_overlapping(self):
"""
Two appointments where the second finishes a minute after the previous started
Should raise Validation Error
"""
data = self.data()
# Start at 9:45
data['start'] = next_tuesday().replace(hour=9, minute=45)
a1 = book_appointment(**data)
self.assertIsInstance(a1, Appointment)
# Starts at 9:16 finishes at 9:46 (a minute after previous started)
data['start'] = next_tuesday().replace(hour=9, minute=16)
a2 = book_appointment(**data, ignore_availability=True)
self.assertIsInstance(a2, Appointment)
# the bellow should not throw an error
a2.delete()
def test_get_inside_locked_period(self):
"""
When an employee has a locked period that ranges for days, no slots should be retrieved for the full range.
"""
lock = util.book_appointment(
self.emp,
start=util.next_tuesday().replace(hour=9, minute=15),
end=util.next_tuesday(7).replace(hour=9, minute=15))
slots = self.get_slots_for_emp(util.next_wednesday())
self.assertEqual(len(slots), 0)
def test_two_appointments_same_time(self):
"""
Two appointments on the exact same start / end time, the second should error and not create
"""
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
self.assertRaises(ValidationError, book_appointment, **data)
def test_two_appointments_start_a_minute_before_end_of_previous(self):
"""
Appointment starts a minute before previous appointment has finished
Should Fail
"""
data = self.data()
# Starts at 9 finishes at 9:30
data['start'] = next_tuesday().replace(hour=9, minute=0)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
# Starts at 9:29 (the end of previous appointment)
data['start'] = next_tuesday().replace(hour=9, minute=29)
self.assertRaises(ValidationError, book_appointment, **data)
def test_delete_appointments_should_not_show_on_all_queryset(self):
"""
The normal objects.all should not return safe deleted appointments
:return:
"""
before = [*Appointment.objects.all()]
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
created = book_appointment(**data)
after_create = [*Appointment.objects.all()]
self.assertEqual(len(before) + 1, len(after_create))
created.delete()
after_delete = [*Appointment.objects.all()]
self.assertEqual(len(before), len(after_delete))
def lock_period(self, start, end):
return util.book_appointment(self.emp,
start=start,
end=end,
ignore_availability=True)
def book_appointment(self, date):
return util.book_appointment(self.emp, self.customer, date,
self.service)
def test_add_appointment_scheduled_day_correct_time(self):
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
appointment = book_appointment(**data)
self.assertIsInstance(appointment, Appointment)
