def test_add_two_appointments_same_service(self):
"""
if the person is not the same as the user's person save should fail
"""
params = {
'start': next_tuesday().replace(hour=9, minute=0),
'service_id': 1,
'customer_id': 2001,
'employee_id': 1,
'owner_id': 1
}
request = get_current() # Get request
request.add_appointment(**params) # Adds appointment
# Adds a new appointment with the same service for another time
params['start'] = next_tuesday().replace(hour=11,
minute=0,
second=0,
microsecond=0)
request.add_appointment(**params)
# Make sure there's a single appointment in the request
self.assertEqual(len(request.appointment_set.all()), 1)
# Make sure the date is related to the last appointment booked
self.assertEqual(request.appointment_set.first().start,
params['start'])
def test_admin_update_overlapping_ignore_availability(self):
"""
When creating overlapping appointments
the server should return 422 error
"""
emp, customer, service = emp_customer_service()
self._auth_as_admin()
# Create appointment at 10 am finishing at 10:30
d1 = create_apt_data(emp, customer, service,
util.next_tuesday().replace(hour=10, minute=0))
r1 = self.client.post(self.list_url, d1, format='json')
self.assertEqual(r1.status_code, status.HTTP_201_CREATED)
# Create appointment at 10:40 (not overlapping)
d2 = create_apt_data(emp, customer, service,
util.next_tuesday().replace(hour=10, minute=40))
r2 = self.client.post(self.list_url, d2, format='json')
self.assertEqual(r2.status_code, status.HTTP_201_CREATED)
# Update previous to overlap with first
d3 = create_apt_data(emp, customer, service,
util.next_tuesday().replace(hour=10, minute=15))
d3['ignore_availability'] = True
r3 = self.client.patch(self.detail_url(r2.data['id']),
d3,
format='json')
self.assertEqual(r3.status_code, status.HTTP_200_OK)
def test_book_appointment_without_service(self):
"""Only self appointment can be created without services"""
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
data['end'] = next_tuesday().replace(hour=10, minute=0)
del (data['service'])
self.assertRaises(ValidationError, book_appointment, **data)
def test_book_self_appointment(self):
"""self appointment should be possible, when this happens the service field will be null"""
employee = self.data()['employee']
appointment = Appointment.objects.create(
start=next_tuesday().replace(hour=9, minute=0),
end=next_tuesday().replace(hour=10, minute=0),
employee=employee,
owner=employee.owner)
self.assertIsInstance(appointment, Appointment)
def test_shift_with_break(self):
appointment_1_date = util.next_tuesday().replace(hour=15, minute=30)
self.book_appointment(appointment_1_date)
slots = self.get_slots_for_emp(util.next_tuesday())
for slot in slots:
self.assertEqual(slot.duration(), self.service.duration)
self.assertEqual(len(slots), 13)
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_slot_(self):
appointment_1_date = util.next_tuesday().replace(hour=9, minute=0)
appointment_2_date = util.next_tuesday().replace(hour=10, minute=0)
self.book_appointment(appointment_1_date)
self.book_appointment(appointment_2_date)
slots = self.get_slots_for_emp(util.next_tuesday())
for slot in slots:
self.assertEqual(slot.duration(), self.service.duration)
self.assertEqual(len(slots), 12)
def test_employee_create_self_appointment(self):
emp, customer, service = emp_customer_service()
emp.user = test_user(emp)
data = create_self_apt_data(
emp,
util.next_tuesday().replace(hour=10, minute=0),
util.next_tuesday().replace(hour=11, minute=0))
self.client.force_authenticate(user=emp.user)
response = self.client.post(self.list_url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
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_admin_view_self_appointment_multiple_days(self):
emp, customer, service = emp_customer_service()
start_date = util.next_tuesday().replace(hour=10,
minute=0) + util.timedelta(7)
end_date = util.next_tuesday().replace(hour=11,
minute=0) + util.timedelta(14)
data = create_self_apt_data(emp, start_date, end_date)
self._auth_as_admin()
# Create an appointment that has 7 days of length
response = self.client.post(self.list_url + 'lock/',
data,
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
apt_id = response.data['id']
for i in range(8):
# Goes through all the dates the appointment is booked and checks that the appointment is being retrieved
# in the results
date = start_date + util.timedelta(i)
q_data = {
'from_date': date.strftime('%Y-%m-%dT00:00'),
'to_date': date.strftime('%Y-%m-%dT23:59')
}
q = self.client.get(self.list_url, q_data, format='json')
self.assertEqual(q.status_code, status.HTTP_200_OK)
result_id = q.data['results'][0]['id']
self.assertEqual(result_id, apt_id)
# The appointment shouldn't be showing on the day before
d_before = start_date - util.timedelta(1)
q_before_data = {
'from_date': d_before.strftime('%Y-%m-%dT00:00'),
'to_date': d_before.strftime('%Y-%m-%dT23:59')
}
q_before = self.client.get(self.list_url, q_before_data, format='json')
self.assertEqual(q_before.status_code, status.HTTP_200_OK)
results = q_before.data['results']
self.assertEqual(len(results), 0)
# The appointment shouldn't be showing on the day after
d_after = start_date + util.timedelta(8)
q_after_data = {
'from_date': d_after.strftime('%Y-%m-%dT00:00'),
'to_date': d_after.strftime('%Y-%m-%dT23:59')
}
q_after = self.client.get(self.list_url, q_after_data, format='json')
self.assertEqual(q_after.status_code, status.HTTP_200_OK)
results = q_after.data['results']
self.assertEqual(len(results), 0)
def test_appointment_end_a_minute_after_next_starts(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)
self.assertRaises(ValidationError, book_appointment, **data)
def test_admin_create_self_appointment(self):
emp, customer, service = emp_customer_service()
data = create_self_apt_data(
emp,
util.next_tuesday().replace(hour=10, minute=0),
util.next_tuesday().replace(hour=11, minute=0))
self._auth_as_admin()
response = self.client.post(self.list_url + 'lock/',
data,
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
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_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_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_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_day_with_one_appointment_start_of_shift(self):
appointment_1_date = util.next_tuesday().replace(hour=9, minute=00)
self.book_appointment(appointment_1_date)
slots = self.get_slots_for_emp(appointment_1_date)
for slot in slots:
self.assertEqual(slot.duration(), self.service.duration)
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_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_add_appointment_scheduled_day_incorrect_time(self):
"""
trying to schedule a 30 minutes job at 8 am when the schedule starts at 9 am
this should throw an exception and not schedule anything
"""
data = self.data()
data['start'] = next_tuesday().replace(hour=8, minute=0)
self.assertRaises(ValidationError, book_appointment, **data)
def test_rejected_appointment(self):
appointment_1_date = util.next_tuesday().replace(hour=9, minute=15)
appointment = self.book_appointment(appointment_1_date)
util.reject_appointment(appointment)
slots = self.get_slots_for_emp(appointment_1_date)
self.assertEqual(len(slots), 14)
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_admin_create_self_appointment_overlapping(self):
self._auth_as_admin()
emp, customer, service = emp_customer_service()
d1 = create_self_apt_data(
emp,
util.next_tuesday().replace(hour=10, minute=0),
util.next_tuesday().replace(hour=12, minute=0))
r1 = self.client.post(self.list_url + 'lock/', d1, format='json')
self.assertEqual(r1.status_code, status.HTTP_201_CREATED)
d2 = create_self_apt_data(
emp,
util.next_tuesday().replace(hour=11, minute=0),
util.next_tuesday().replace(hour=13, minute=0))
r2 = self.client.post(self.list_url + 'lock/', d2, format='json')
self.assertEqual(r2.status_code, status.HTTP_422_UNPROCESSABLE_ENTITY)
def test_accept(self):
params = {
'start': next_tuesday().replace(hour=9, minute=0),
'service_id': 1,
'customer_id': 2001,
'employee_id': 1,
'owner_id': 1
}
request = get_current() # Get request
request.add_appointment(**params) # Adds appointment
params.update({
'service_id': 2,
'start': next_tuesday().replace(hour=11)
})
self.assert_request_status(request, Appointment.PENDING)
request.accept()
self.assert_request_status(request, Appointment.ACCEPTED)
def test_appointment_with_customer_and_employees_on_different_owner(self):
"""
An error should be raised when creating an appointment where the service and the employee have different owners
"""
data = self.data()
data['start'] = next_tuesday().replace(hour=9, minute=0)
data['customer'] = Customer.objects.get(pk=1003)
self.assertRaises(ValidationError, book_appointment, **data)
def test_customer_create_pending(self):
emp, service = emp_service()
user = test_user()
data = create_apt_data(emp, user.person, service,
util.next_tuesday().replace(hour=10, minute=0))
self.client.force_authenticate(user=user) # authenticates as customer
response = self.client.post(self.list_url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_admin_create_different_company(self):
emp, customer, service = emp_customer_service_company_2()
data = create_apt_data(emp, customer, service,
util.next_tuesday().replace(hour=10, minute=0))
self._auth_as_admin()
response = self.client.post(self.list_url, data, format='json')
self.assertEqual(response.status_code,
status.HTTP_422_UNPROCESSABLE_ENTITY)
def test_add_appointment_no_employee(self):
"""
requests can have appointments without an employee id
"""
r1 = get_current()
r1.add_appointment(start=next_tuesday().replace(hour=9, minute=0),
service_id=1,
customer_id=2001,
owner_id=1)
self.assertEqual(len(r1.appointment_set.all()), 1)
def test_create_appointment_omitting_employee(self):
emp, service = emp_service()
user = User.objects.get(pk=2)
data = create_apt_data(emp, service, util.next_tuesday().replace(hour=10, minute=0))
data.pop('employee')
self.client.force_authenticate(user=user)
response = self.client.post(self.list_url + 'add/', data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
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)
